From 6585f9948569bd4ed768ba8a9cb4563d94988e4f Mon Sep 17 00:00:00 2001 From: Lenz Weber-Tronic Date: Fri, 31 Jan 2025 10:03:38 +0100 Subject: [PATCH] Clean up build scripts (#12305) * move from `ts-node` to `node --experimental-strip-types`, create `build.ts` * remove `engines` field, specify `devEngines` * adjust node version for CI * fix up some more syntax * prettier * adjust precheck, bump minimal lockfile version to 3 * convert jest config to esm * move `entryPoints` to TS, make it work in mjs and jest * run rollup with ts config * update a few more node calls * some more typings * move all scripts to function invocation * migrate `prepareChangestsRelease` too * remove scripts that are not called manually * convert `prepareDist` to TS * migrate `precheck.js` * `version.js->ts` * use jest ts config * prettier * dirname.cjs->cts * dirname-related import fixes * fix up new knip issues * delete `devEngines` instead of `engines` field * require node 23.6 instead of 22.6 --- .github/workflows/api-extractor.yml | 4 +- .github/workflows/arethetypeswrong.yml | 4 +- .github/workflows/change-prerelease-tag.yml | 4 +- .github/workflows/cleanup-checks.yml | 4 +- .github/workflows/compare-build-output.yml | 4 +- .github/workflows/exit-prerelease.yml | 4 +- .github/workflows/prerelease.yml | 4 +- .github/workflows/publish-pr-releases.yml | 4 +- .github/workflows/release.yml | 4 +- .github/workflows/size-limit.yml | 4 +- .github/workflows/snapshot-release.yml | 4 +- .vscode/launch.json | 2 +- .vscode/settings.json | 2 +- CONTRIBUTING.md | 2 +- config/apiExtractor.ts | 14 +- config/build.ts | 63 + config/bundlesize.ts | 2 +- config/dirname.cts | 4 + config/{entryPoints.js => entryPoints.ts} | 43 +- config/helpers.ts | 6 +- config/inlineInheritDoc.ts | 29 +- config/{jest.config.js => jest.config.ts} | 8 +- config/package.json | 3 + config/postprocessDist.ts | 25 +- config/{precheck.js => precheck.ts} | 5 +- config/prepareChangesetsRelease.ts | 15 +- config/prepareDist.js | 105 - config/prepareDist.ts | 113 + config/processInvariants.ts | 435 +- config/rewriteSourceMaps.ts | 61 +- config/{rollup.config.js => rollup.config.ts} | 9 +- config/rollup.ts | 13 + config/schema.package.json.ts | 52492 ++++++++++++++++ config/tsconfig.json | 25 +- config/version.js | 66 - config/version.ts | 60 + ...id-act-in-disabled-act-environment.test.ts | 4 +- eslint-local-rules/index.js | 18 - eslint-local-rules/index.mjs | 9 + eslint-local-rules/package.json | 3 +- .../require-disable-act-environment.test.ts | 4 +- .../require-disable-act-environment.ts | 4 +- .../require-using-disposable.test.ts | 4 +- eslint-local-rules/testSetup.ts | 2 +- eslint-local-rules/tsconfig.json | 11 +- eslint.config.mjs | 27 +- knip.config.js | 13 +- package-lock.json | 8336 +-- package.json | 49 +- patches/jest-config+29.7.0.patch | 13 + src/__tests__/exports.ts | 2 +- 51 files changed, 56304 insertions(+), 5841 deletions(-) create mode 100644 config/build.ts create mode 100644 config/dirname.cts rename config/{entryPoints.js => entryPoints.ts} (79%) rename config/{jest.config.js => jest.config.ts} (93%) create mode 100644 config/package.json rename config/{precheck.js => precheck.ts} (68%) delete mode 100644 config/prepareDist.js create mode 100644 config/prepareDist.ts rename config/{rollup.config.js => rollup.config.ts} (95%) create mode 100644 config/rollup.ts create mode 100644 config/schema.package.json.ts delete mode 100644 config/version.js create mode 100644 config/version.ts delete mode 100644 eslint-local-rules/index.js create mode 100644 eslint-local-rules/index.mjs create mode 100644 patches/jest-config+29.7.0.patch diff --git a/.github/workflows/api-extractor.yml b/.github/workflows/api-extractor.yml index b54d5e078aa..c46ca0eb66f 100644 --- a/.github/workflows/api-extractor.yml +++ b/.github/workflows/api-extractor.yml @@ -11,10 +11,10 @@ jobs: - name: Checkout repo uses: actions/checkout@v4 - - name: Setup Node.js 20.x + - name: Setup Node.js uses: actions/setup-node@v4 with: - node-version: 20.x + node-version: ">=23.6.0" - name: Install dependencies (with cache) uses: bahmutov/npm-install@v1 diff --git a/.github/workflows/arethetypeswrong.yml b/.github/workflows/arethetypeswrong.yml index c83c623241f..a95d1bb3fc4 100644 --- a/.github/workflows/arethetypeswrong.yml +++ b/.github/workflows/arethetypeswrong.yml @@ -14,10 +14,10 @@ jobs: steps: - name: Checkout repo uses: actions/checkout@v4 - - name: Setup Node.js 20.x + - name: Setup Node.js uses: actions/setup-node@v4 with: - node-version: 20.x + node-version: ">=23.6.0" - name: Install dependencies (with cache) uses: bahmutov/npm-install@v1 diff --git a/.github/workflows/change-prerelease-tag.yml b/.github/workflows/change-prerelease-tag.yml index 208f10d0b57..7c6250d7424 100644 --- a/.github/workflows/change-prerelease-tag.yml +++ b/.github/workflows/change-prerelease-tag.yml @@ -41,10 +41,10 @@ jobs: # with the correct commits fetch-depth: 0 - - name: Setup Node.js 20.x + - name: Setup Node.js uses: actions/setup-node@v4 with: - node-version: 20.x + node-version: ">=23.6.0" - name: Write latest version to package.json and package-lock.json run: | diff --git a/.github/workflows/cleanup-checks.yml b/.github/workflows/cleanup-checks.yml index 7f91d6ce1db..1504bc4c20a 100644 --- a/.github/workflows/cleanup-checks.yml +++ b/.github/workflows/cleanup-checks.yml @@ -32,10 +32,10 @@ jobs: - name: Checkout repo uses: actions/checkout@v4 - - name: Setup Node.js 20.x + - name: Setup Node.js uses: actions/setup-node@v4 with: - node-version: 20.x + node-version: ">=23.6.0" - name: Install dependencies (with cache) uses: bahmutov/npm-install@v1 diff --git a/.github/workflows/compare-build-output.yml b/.github/workflows/compare-build-output.yml index b367e4672e6..fb61b1f732a 100644 --- a/.github/workflows/compare-build-output.yml +++ b/.github/workflows/compare-build-output.yml @@ -14,10 +14,10 @@ jobs: with: # Fetch entire git history so we have the parent commit to compare against fetch-depth: 0 - - name: Setup Node.js 20.x + - name: Setup Node.js uses: actions/setup-node@v4 with: - node-version: 20.x + node-version: ">=23.6.0" - name: Install dependencies (with cache) uses: bahmutov/npm-install@v1 diff --git a/.github/workflows/exit-prerelease.yml b/.github/workflows/exit-prerelease.yml index 6ac4e76b1a8..7f313ee7bd6 100644 --- a/.github/workflows/exit-prerelease.yml +++ b/.github/workflows/exit-prerelease.yml @@ -36,10 +36,10 @@ jobs: # with the correct commits fetch-depth: 0 - - name: Setup Node.js 20.x + - name: Setup Node.js uses: actions/setup-node@v4 with: - node-version: 20.x + node-version: ">=23.6.0" - name: Write latest version to package.json and package-lock.json run: | diff --git a/.github/workflows/prerelease.yml b/.github/workflows/prerelease.yml index 852ec7de291..521e0c68fe0 100644 --- a/.github/workflows/prerelease.yml +++ b/.github/workflows/prerelease.yml @@ -47,10 +47,10 @@ jobs: env: NPM_TOKEN: ${{ secrets.NPM_TOKEN }} - - name: Setup Node.js 20.x + - name: Setup Node.js uses: actions/setup-node@v4 with: - node-version: 20.x + node-version: ">=23.6.0" - name: Install dependencies with cache uses: bahmutov/npm-install@v1 diff --git a/.github/workflows/publish-pr-releases.yml b/.github/workflows/publish-pr-releases.yml index 24bcc481079..69e63d3ff2d 100644 --- a/.github/workflows/publish-pr-releases.yml +++ b/.github/workflows/publish-pr-releases.yml @@ -16,10 +16,10 @@ jobs: - name: Checkout repo uses: actions/checkout@v4 - - name: Setup Node.js 20.x + - name: Setup Node.js uses: actions/setup-node@v4 with: - node-version: 20.x + node-version: ">=23.6.0" - name: Install dependencies with cache uses: bahmutov/npm-install@v1 diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index dd16a06bfb1..44ef0d58131 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -43,10 +43,10 @@ jobs: env: NPM_TOKEN: ${{ secrets.NPM_TOKEN }} - - name: Setup Node.js 20.x + - name: Setup Node.js uses: actions/setup-node@v4 with: - node-version: 20.x + node-version: ">=23.6.0" - name: Install dependencies (with cache) uses: bahmutov/npm-install@v1 diff --git a/.github/workflows/size-limit.yml b/.github/workflows/size-limit.yml index 2295fc46951..15c2862771b 100644 --- a/.github/workflows/size-limit.yml +++ b/.github/workflows/size-limit.yml @@ -11,10 +11,10 @@ jobs: steps: - name: Checkout repo uses: actions/checkout@v4 - - name: Setup Node.js 20.x + - name: Setup Node.js uses: actions/setup-node@v4 with: - node-version: 20.x + node-version: ">=23.6.0" - name: Install dependencies (with cache) uses: bahmutov/npm-install@v1 - name: Run size-limit diff --git a/.github/workflows/snapshot-release.yml b/.github/workflows/snapshot-release.yml index 4b21f629c09..a3bbc63f6e1 100644 --- a/.github/workflows/snapshot-release.yml +++ b/.github/workflows/snapshot-release.yml @@ -90,10 +90,10 @@ jobs: env: NPM_TOKEN: ${{ secrets.NPM_TOKEN }} - - name: Setup Node.js 20.x + - name: Setup Node.js uses: actions/setup-node@v4 with: - node-version: 20.x + node-version: ">=23.6.0" - name: Install dependencies (with cache) uses: bahmutov/npm-install@v1 diff --git a/.vscode/launch.json b/.vscode/launch.json index d40a6ff9315..6d8ef694de4 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -11,7 +11,7 @@ "${workspaceRoot}/node_modules/.bin/jest", "${relativeFile}", "--config", - "./config/jest.config.js", + "./config/jest.config.ts", "--runInBand", "--watch" ], diff --git a/.vscode/settings.json b/.vscode/settings.json index c2580b79482..85454910ede 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -6,5 +6,5 @@ "files.insertFinalNewline": true, "typescript.tsdk": "node_modules/typescript/lib", "cSpell.enableFiletypes": ["mdx"], - "jest.jestCommandLine": "node --expose-gc node_modules/.bin/jest --config ./config/jest.config.js --ignoreProjects 'ReactDOM 17' --runInBand" + "jest.jestCommandLine": "node --expose-gc node_modules/.bin/jest --config ./config/jest.config.ts --ignoreProjects 'ReactDOM 17' --runInBand" } diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 22afe337585..d65fd7964f0 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -117,7 +117,7 @@ npm run test:watch Call jest directly making sure to pass in the jest config, and use its `testRegex` option: ``` -jest --config ./config/jest.config.js --testRegex __tests__/useQuery.test.tsx +jest --config ./config/jest.config.ts --testRegex __tests__/useQuery.test.tsx ``` ### Wiring a checkout into an application diff --git a/config/apiExtractor.ts b/config/apiExtractor.ts index 53cd00b89c4..9d0e5112b59 100644 --- a/config/apiExtractor.ts +++ b/config/apiExtractor.ts @@ -1,15 +1,15 @@ import * as path from "path"; +import type { IConfigFile } from "@microsoft/api-extractor"; import { Extractor, ExtractorConfig, ExtractorLogLevel, - IConfigFile, } from "@microsoft/api-extractor"; import { parseArgs } from "node:util"; import fs from "node:fs"; // @ts-ignore -import { map, buildDocEntryPoints } from "./entryPoints.js"; +import { map, buildDocEntryPoints } from "./entryPoints.ts"; import { readFileSync } from "fs"; const parsed = parseArgs({ @@ -35,9 +35,15 @@ if ( } // Load and parse the api-extractor.json file -const configObjectFullPath = path.resolve(__dirname, "../api-extractor.json"); +const configObjectFullPath = path.resolve( + import.meta.dirname, + "../api-extractor.json" +); const baseConfig = ExtractorConfig.loadFile(configObjectFullPath); -const packageJsonFullPath = path.resolve(__dirname, "../package.json"); +const packageJsonFullPath = path.resolve( + import.meta.dirname, + "../package.json" +); process.exitCode = 0; diff --git a/config/build.ts b/config/build.ts new file mode 100644 index 00000000000..f93681563fb --- /dev/null +++ b/config/build.ts @@ -0,0 +1,63 @@ +import { $ } from "zx"; +import { join } from "node:path"; +import { parseArgs } from "node:util"; + +import { inlineInheritDoc } from "./inlineInheritDoc.ts"; +import { updateVersion, verifyVersion } from "./version.ts"; +import { processInvariants } from "./processInvariants.ts"; +import { rewriteSourceMaps } from "./rewriteSourceMaps.ts"; +import { rollup } from "./rollup.ts"; +import { prepareDist } from "./prepareDist.ts"; +import { postprocessDist } from "./postprocessDist.ts"; +import { prepareChangesetsRelease } from "./prepareChangesetsRelease.ts"; + +$.cwd = join(import.meta.dirname, ".."); +$.verbose = true; + +const buildSteps = { + typescript: () => $`npx tsc`, + updateVersion, + inlineInheritDoc, + processInvariants, + rewriteSourceMaps, + rollup, + prepareDist, + postprocessDist, + verifyVersion, +}; +const additionalSteps = { + prepareChangesetsRelease, +}; + +const args = parseArgs({ + options: { + step: { + type: "string", + multiple: true, + default: ["build"], + }, + }, +}); + +const allSteps = Object.assign({}, buildSteps, additionalSteps); + +const runSteps = args.values.step.flatMap((step) => + step === "build" ? Object.keys(buildSteps) : [step] +); + +const wrongSteps = runSteps.filter((step) => !(step in allSteps)); +if (wrongSteps.length) { + throw new Error( + `Unknown steps: ${wrongSteps.join(", ")}. Valid steps are ${Object.keys( + allSteps + ).join(", ")}` + ); +} + +console.log("Running build steps: %s", runSteps.join(", ")); + +for (const step of runSteps) { + console.log("--- Step %s: running ---", step); + await allSteps[step](); + console.log("--- Step %s: done ---", step); +} diff --git a/config/bundlesize.ts b/config/bundlesize.ts index 4a5ad18177b..fbf636cc0af 100644 --- a/config/bundlesize.ts +++ b/config/bundlesize.ts @@ -5,7 +5,7 @@ import bytes from "bytes"; const gzipBundleByteLengthLimit = bytes("35.25KB"); const minFile = join("dist", "apollo-client.min.cjs"); -const minPath = join(__dirname, "..", minFile); +const minPath = join(import.meta.dirname, "..", minFile); const gzipByteLen = gzipSync(readFileSync(minPath)).byteLength; const overLimit = gzipByteLen > gzipBundleByteLengthLimit; diff --git a/config/dirname.cts b/config/dirname.cts new file mode 100644 index 00000000000..329c3956577 --- /dev/null +++ b/config/dirname.cts @@ -0,0 +1,4 @@ +// workaround for `entryPoints.ts` that needs access to the current directory, +// but cannot use `import.meta` as the file is required by Jest, which transpiles +// the file to CommonJS - ending up with "SyntaxError: Cannot use 'import.meta' outside a module" +module.exports.__dirname = __dirname; diff --git a/config/entryPoints.js b/config/entryPoints.ts similarity index 79% rename from config/entryPoints.js rename to config/entryPoints.ts index 83ebae6adf9..9c502443204 100644 --- a/config/entryPoints.js +++ b/config/entryPoints.ts @@ -1,3 +1,13 @@ +import path from "path"; +// @ts-expect-error An import path can only end with a '.cts' extension when 'allowImportingTsExtensions' is enabled. +import { __dirname } from "./dirname.cts"; + +type EntryPoint = { + dirs: string[]; + bundleName?: string; + extensions?: string[]; + sideEffects?: boolean; +}; const entryPoints = [ { dirs: [], bundleName: "main" }, { dirs: ["cache"] }, @@ -32,7 +42,7 @@ const entryPoints = [ { dirs: ["utilities", "subscriptions", "relay"] }, { dirs: ["utilities", "subscriptions", "urql"] }, { dirs: ["utilities", "globals"], sideEffects: true }, -]; +] satisfies EntryPoint[]; const lookupTrie = Object.create(null); entryPoints.forEach((info) => { @@ -44,17 +54,21 @@ entryPoints.forEach((info) => { node.isEntry = true; }); -exports.forEach = function (callback, context) { +export const forEach = function ( + callback: (value: EntryPoint, index: number, array: EntryPoint[]) => void, + context?: any +) { entryPoints.forEach(callback, context); }; -exports.map = function map(callback, context) { +export const map = function map( + callback: (value: EntryPoint, index: number, array: EntryPoint[]) => U, + context?: any +) { return entryPoints.map(callback, context); }; -const path = require("path").posix; - -exports.check = function (id, parentId) { +export const check = function (id: string, parentId: string) { const resolved = path.resolve(path.dirname(parentId), id); const importedParts = partsAfterDist(resolved); @@ -91,7 +105,7 @@ exports.check = function (id, parentId) { return false; }; -function partsAfterDist(id) { +function partsAfterDist(id: string): string[] { const parts = id.split(path.sep); const distIndex = parts.lastIndexOf("dist"); if (/^index.jsx?$/.test(parts[parts.length - 1])) { @@ -100,15 +114,10 @@ function partsAfterDist(id) { if (distIndex >= 0) { return parts.slice(distIndex + 1); } + return []; } -exports.getEntryPointDirectory = function (file) { - const parts = partsAfterDist(file) || file.split(path.sep); - const len = lengthOfLongestEntryPoint(parts); - if (len >= 0) return parts.slice(0, len).join(path.sep); -}; - -function lengthOfLongestEntryPoint(parts) { +function lengthOfLongestEntryPoint(parts: string[]) { let node = lookupTrie; let longest = -1; for (let i = 0; node && i < parts.length; ++i) { @@ -121,16 +130,16 @@ function lengthOfLongestEntryPoint(parts) { return longest; } -function arraysEqualUpTo(a, b, end) { +function arraysEqualUpTo(a: unknown[], b: unknown[], end: number) { for (let i = 0; i < end; ++i) { if (a[i] !== b[i]) return false; } return true; } -exports.buildDocEntryPoints = () => { +export const buildDocEntryPoints = () => { const dist = path.resolve(__dirname, "../dist"); - const entryPoints = exports.map((entryPoint) => { + const entryPoints = map((entryPoint) => { return `export * from "${dist}/${entryPoint.dirs.join("/")}/index.d.ts";`; }); entryPoints.push( diff --git a/config/helpers.ts b/config/helpers.ts index 58c306ae378..1c17f44175d 100644 --- a/config/helpers.ts +++ b/config/helpers.ts @@ -1,9 +1,9 @@ import * as path from "path"; import * as recast from "recast"; -import * as parser from "recast/parsers/babel"; -import glob = require("glob"); +import * as parser from "recast/parsers/babel.js"; +import glob from "glob"; -export const distDir = path.resolve(__dirname, "..", "dist"); +export const distDir = path.resolve(import.meta.dirname, "..", "dist"); export function eachFile( dir: string, diff --git a/config/inlineInheritDoc.ts b/config/inlineInheritDoc.ts index 558be9f375f..d1bb2563cad 100644 --- a/config/inlineInheritDoc.ts +++ b/config/inlineInheritDoc.ts @@ -24,11 +24,11 @@ /** End file docs */ // @ts-ignore -import { buildDocEntryPoints } from "./entryPoints.js"; +import { buildDocEntryPoints } from "./entryPoints.ts"; // @ts-ignore import { Project, ts, printNode, Node } from "ts-morph"; import { ApiModel, ApiDocumentedItem } from "@microsoft/api-extractor-model"; -import { DeclarationReference } from "@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference"; +import { DeclarationReference } from "@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference.js"; import { StringBuilder, TSDocEmitter } from "@microsoft/tsdoc"; import fs from "node:fs"; @@ -39,14 +39,16 @@ import { ExtractorLogLevel, } from "@microsoft/api-extractor"; -console.log( - "Processing {@inheritDoc } comments in .d.ts files." -); +export function inlineInheritDoc() { + console.log( + "Processing {@inheritDoc } comments in .d.ts files." + ); -const model = loadApiModel(); -processComments(); + const model = loadApiModel(); + processComments(model); +} -function getCommentFor(canonicalReference: string) { +function getCommentFor(canonicalReference: string, model: ApiModel) { const apiItem = model.resolveDeclarationReference( DeclarationReference.parse(canonicalReference), undefined @@ -77,10 +79,13 @@ function loadApiModel() { // Load and parse the api-extractor.json file const configObjectFullPath = path.resolve( - __dirname, + import.meta.dirname, "../api-extractor.json" ); - const packageJsonFullPath = path.resolve(__dirname, "../package.json"); + const packageJsonFullPath = path.resolve( + import.meta.dirname, + "../package.json" + ); const tempModelFile = path.join(tempDir, "client.api.json"); const configObject = ExtractorConfig.loadFile(configObjectFullPath); @@ -129,7 +134,7 @@ function loadApiModel() { } } -function processComments() { +function processComments(model: ApiModel) { const inheritDocRegex = /\{@inheritDoc ([^}]+)\}/; const project = new Project({ @@ -155,7 +160,7 @@ function processComments() { newText = newText.replace( inheritDocRegex, (_, canonicalReference) => { - return getCommentFor(canonicalReference) || ""; + return getCommentFor(canonicalReference, model) || ""; } ); } diff --git a/config/jest.config.js b/config/jest.config.ts similarity index 93% rename from config/jest.config.js rename to config/jest.config.ts index 1e0d714b4ac..860680d7b84 100644 --- a/config/jest.config.js +++ b/config/jest.config.ts @@ -1,7 +1,11 @@ +import { fileURLToPath } from "node:url"; + const defaults = { rootDir: "src", preset: "ts-jest", - testEnvironment: require.resolve("./FixJSDOMEnvironment.js"), + testEnvironment: fileURLToPath( + import.meta.resolve("./FixJSDOMEnvironment.js") + ), setupFilesAfterEnv: ["/config/jest/setup.ts"], globals: { __DEV__: true, @@ -81,7 +85,7 @@ const standardReact17Config = { }, }; -module.exports = { +export default { projects: [ tsStandardConfig, standardReact17Config, diff --git a/config/package.json b/config/package.json new file mode 100644 index 00000000000..3dbc1ca591c --- /dev/null +++ b/config/package.json @@ -0,0 +1,3 @@ +{ + "type": "module" +} diff --git a/config/postprocessDist.ts b/config/postprocessDist.ts index 6599c54ad0f..30a8d8cc519 100644 --- a/config/postprocessDist.ts +++ b/config/postprocessDist.ts @@ -2,13 +2,18 @@ import { distDir } from "./helpers.ts"; import fs from "node:fs"; import path from "node:path"; -const globalTypesFile = path.resolve(distDir, "utilities/globals/global.d.ts"); -fs.writeFileSync( - globalTypesFile, - fs - .readFileSync(globalTypesFile, "utf8") - .split("\n") - .filter((line) => line.trim() !== "const __DEV__: boolean;") - .join("\n"), - "utf8" -); +export function postprocessDist() { + const globalTypesFile = path.resolve( + distDir, + "utilities/globals/global.d.ts" + ); + fs.writeFileSync( + globalTypesFile, + fs + .readFileSync(globalTypesFile, "utf8") + .split("\n") + .filter((line) => line.trim() !== "const __DEV__: boolean;") + .join("\n"), + "utf8" + ); +} diff --git a/config/precheck.js b/config/precheck.ts similarity index 68% rename from config/precheck.js rename to config/precheck.ts index 31548802c02..8a2f4bc391f 100644 --- a/config/precheck.js +++ b/config/precheck.ts @@ -1,6 +1,7 @@ -const { lockfileVersion } = require("../package-lock.json"); +import lockfile from "../package-lock.json" with { type: "json" }; +const { lockfileVersion } = lockfile; -const expectedVersion = 2; +const expectedVersion = 3; if (typeof lockfileVersion !== "number" || lockfileVersion < expectedVersion) { throw new Error( diff --git a/config/prepareChangesetsRelease.ts b/config/prepareChangesetsRelease.ts index 171503939b0..6deefa55adf 100644 --- a/config/prepareChangesetsRelease.ts +++ b/config/prepareChangesetsRelease.ts @@ -14,11 +14,10 @@ // - Add both .changeset and CHANGELOG.md to an .npmignore so they are not // included in the published package. -const fs = require("fs"); -const path = require("path"); +import fs from "node:fs"; +import path from "node:path"; -const distRoot = `${__dirname}/../dist`; -const srcDir = `${__dirname}/..`; +const srcDir = `${import.meta.dirname}/..`; const destDir = `${srcDir}/dist`; // recursive copy function @@ -36,6 +35,8 @@ function copyDir(src: string, dest: string) { } } -fs.copyFileSync(`${srcDir}/CHANGELOG.md`, `${destDir}/CHANGELOG.md`); -copyDir(`${srcDir}/.changeset`, `${destDir}/.changeset`); -fs.writeFileSync(`${destDir}/.npmignore`, `.changeset\nCHANGELOG.md`); +export async function prepareChangesetsRelease() { + fs.copyFileSync(`${srcDir}/CHANGELOG.md`, `${destDir}/CHANGELOG.md`); + copyDir(`${srcDir}/.changeset`, `${destDir}/.changeset`); + fs.writeFileSync(`${destDir}/.npmignore`, `.changeset\nCHANGELOG.md`); +} diff --git a/config/prepareDist.js b/config/prepareDist.js deleted file mode 100644 index 68bfbce2c2e..00000000000 --- a/config/prepareDist.js +++ /dev/null @@ -1,105 +0,0 @@ -// The Apollo Client source that is published to npm is located in the -// "dist" directory. This utility script is called when building Apollo Client, -// to make sure the "dist" directory is prepared for publishing. -// -// This script will: -// -// - Copy the current root package.json into "dist" after adjusting it for -// publishing. -// - Copy the supporting files from the root into "dist" (e.g. `README.MD`, -// `LICENSE`, etc.). -// - Create a new `package.json` for each sub-set bundle we support, and -// store it in the appropriate dist sub-directory. - -const fs = require("fs"); -const path = require("path"); -const recast = require("recast"); - -const distRoot = `${__dirname}/../dist`; - -/* @apollo/client */ - -const packageJson = require("../package.json"); -const entryPoints = require("./entryPoints.js"); - -// Enable default interpretation of .js files as ECMAScript modules. We don't -// put this in the source ../package.json file because it interferes with tools -// like ts-node, which we use to run various ../config/*.ts scripts. -// TODO(benjamn) Fully diagnose that interference. -packageJson.type = "module"; - -// The root package.json is marked as private to prevent publishing -// from happening in the root of the project. This sets the package back to -// public so it can be published from the "dist" directory. -packageJson.private = false; - -// Remove package.json items that we don't need to publish -delete packageJson.scripts; -delete packageJson.bundlesize; -delete packageJson.engines; - -// The root package.json points to the CJS/ESM source in "dist", to support -// on-going package development (e.g. running tests, supporting npm link, etc.). -// When publishing from "dist" however, we need to update the package.json -// to point to the files within the same directory. -const distPackageJson = - JSON.stringify( - packageJson, - (_key, value) => { - if (typeof value === "string" && value.startsWith("./dist/")) { - const parts = value.split("/"); - parts.splice(1, 1); // remove dist - return parts.join("/"); - } - return value; - }, - 2 - ) + "\n"; - -// Save the modified package.json to "dist" -fs.writeFileSync(`${distRoot}/package.json`, distPackageJson); - -// Copy supporting files into "dist" -const srcDir = `${__dirname}/..`; -const destDir = `${srcDir}/dist`; -fs.copyFileSync(`${srcDir}/README.md`, `${destDir}/README.md`); -fs.copyFileSync(`${srcDir}/LICENSE`, `${destDir}/LICENSE`); - -// Create individual bundle package.json files, storing them in their -// associated dist directory. This helps provide a way for the Apollo Client -// core to be used without React, as well as AC's cache, utilities, SSR, -// components, HOC, and various links to be used by themselves, via CommonJS -// entry point files that only include the exports needed for each bundle. -entryPoints.forEach(function buildPackageJson({ - dirs, - bundleName = dirs[dirs.length - 1], - sideEffects = false, -}) { - if (!dirs.length) return; - fs.writeFileSync( - path.join(distRoot, ...dirs, "package.json"), - JSON.stringify( - { - name: path.posix.join("@apollo", "client", ...dirs), - type: "module", - main: `${bundleName}.cjs`, - module: "index.js", - types: "index.d.ts", - sideEffects, - }, - null, - 2 - ) + "\n" - ); -}); - -entryPoints.forEach(function buildCts({ - dirs, - bundleName = dirs[dirs.length - 1], -}) { - if (!dirs.length) return; - fs.writeFileSync( - path.join(distRoot, ...dirs, `${bundleName}.d.cts`), - 'export * from "./index.d.ts";\n' - ); -}); diff --git a/config/prepareDist.ts b/config/prepareDist.ts new file mode 100644 index 00000000000..45ce7f07ced --- /dev/null +++ b/config/prepareDist.ts @@ -0,0 +1,113 @@ +// The Apollo Client source that is published to npm is located in the +// "dist" directory. This utility script is called when building Apollo Client, +// to make sure the "dist" directory is prepared for publishing. +// +// This script will: +// +// - Copy the current root package.json into "dist" after adjusting it for +// publishing. +// - Copy the supporting files from the root into "dist" (e.g. `README.MD`, +// `LICENSE`, etc.). +// - Create a new `package.json` for each sub-set bundle we support, and +// store it in the appropriate dist sub-directory. + +import fs from "node:fs"; +import path from "node:path"; + +const distRoot = `${import.meta.dirname}/../dist`; + +/* @apollo/client */ + +import pkg from "../package.json" with { type: "json" }; +import * as entryPoints from "./entryPoints.ts"; +import type { JSONSchemaForNPMPackageJsonFiles } from "./schema.package.json.ts"; + +// the generated `Person` type is a bit weird - `author` as a string is valid +const packageJson: Omit & { + author: string; +} = pkg; + +export function prepareDist() { + // Enable default interpretation of .js files as ECMAScript modules. We don't + // put this in the source ../package.json file because it interferes with tools + // like ts-node, which we use to run various ../config/*.ts scripts. + // TODO(benjamn) Fully diagnose that interference. + packageJson.type = "module"; + + // The root package.json is marked as private to prevent publishing + // from happening in the root of the project. This sets the package back to + // public so it can be published from the "dist" directory. + packageJson.private = false; + + // Remove package.json items that we don't need to publish + delete packageJson.scripts; + delete packageJson.bundlesize; + delete packageJson.devEngines; + delete packageJson.devDependencies; + + // The root package.json points to the CJS/ESM source in "dist", to support + // on-going package development (e.g. running tests, supporting npm link, etc.). + // When publishing from "dist" however, we need to update the package.json + // to point to the files within the same directory. + const distPackageJson = + JSON.stringify( + packageJson, + (_key, value) => { + if (typeof value === "string" && value.startsWith("./dist/")) { + const parts = value.split("/"); + parts.splice(1, 1); // remove dist + return parts.join("/"); + } + return value; + }, + 2 + ) + "\n"; + + // Save the modified package.json to "dist" + fs.writeFileSync(`${distRoot}/package.json`, distPackageJson); + + // Copy supporting files into "dist" + const srcDir = `${import.meta.dirname}/..`; + const destDir = `${srcDir}/dist`; + fs.copyFileSync(`${srcDir}/README.md`, `${destDir}/README.md`); + fs.copyFileSync(`${srcDir}/LICENSE`, `${destDir}/LICENSE`); + + // Create individual bundle package.json files, storing them in their + // associated dist directory. This helps provide a way for the Apollo Client + // core to be used without React, as well as AC's cache, utilities, SSR, + // components, HOC, and various links to be used by themselves, via CommonJS + // entry point files that only include the exports needed for each bundle. + entryPoints.forEach(function buildPackageJson({ + dirs, + bundleName = dirs[dirs.length - 1], + sideEffects = false, + }) { + if (!dirs.length) return; + fs.writeFileSync( + path.join(distRoot, ...dirs, "package.json"), + JSON.stringify( + { + name: path.posix.join("@apollo", "client", ...dirs), + type: "module", + main: `${bundleName}.cjs`, + module: "index.js", + types: "index.d.ts", + sideEffects, + }, + null, + 2 + ) + "\n" + ); + }); + + entryPoints.forEach(function buildCts({ + dirs, + bundleName = dirs[dirs.length - 1], + }) { + if (!dirs.length) return; + fs.writeFileSync( + path.join(distRoot, ...dirs, `${bundleName}.d.cts`), + 'export * from "./index.d.ts";\n' + ); + }); +} diff --git a/config/processInvariants.ts b/config/processInvariants.ts index 13f8e275016..068725eb266 100644 --- a/config/processInvariants.ts +++ b/config/processInvariants.ts @@ -3,276 +3,287 @@ import { posix, join as osPathJoin } from "path"; import { distDir, eachFile, reparse, reprint } from "./helpers.ts"; import type { ExpressionKind } from "ast-types/lib/gen/kinds"; -eachFile(distDir, (file, relPath) => { - const source = fs.readFileSync(file, "utf8"); - const output = transform(source, relPath); - if (source !== output) { - fs.writeFileSync(file, output, "utf8"); - } -}).then(() => { - fs.writeFileSync( - osPathJoin(distDir, "invariantErrorCodes.js"), - recast.print(program, { - tabWidth: 2, - }).code + "\n" - ); -}); - import * as recast from "recast"; const b = recast.types.builders; const n = recast.types.namedTypes; type Node = recast.types.namedTypes.Node; type CallExpression = recast.types.namedTypes.CallExpression; type NewExpression = recast.types.namedTypes.NewExpression; -let nextErrorCode = 1; -const program = b.program([]); -const allExports = { - errorCodes: getExportObject("errorCodes"), - devDebug: getExportObject("devDebug"), - devLog: getExportObject("devLog"), - devWarn: getExportObject("devWarn"), - devError: getExportObject("devError"), -}; -type ExportName = keyof typeof allExports; +export async function processInvariants() { + const program = b.program([]); + let nextErrorCode = 1; -allExports.errorCodes.comments = [ - b.commentLine( - " This file is used by the error message display website and the", - true - ), - b.commentLine(" @apollo/client/includeErrors entry point.", true), - b.commentLine(" This file is not meant to be imported manually.", true), -]; + const allExports = { + errorCodes: getExportObject("errorCodes"), + devDebug: getExportObject("devDebug"), + devLog: getExportObject("devLog"), + devWarn: getExportObject("devWarn"), + devError: getExportObject("devError"), + }; + type ExportName = keyof typeof allExports; -function getExportObject(exportName: string) { - const object = b.objectExpression([]); - program.body.push( - b.exportNamedDeclaration( - b.variableDeclaration("const", [ - b.variableDeclarator(b.identifier(exportName), object), - ]) - ) + allExports.errorCodes.comments = [ + b.commentLine( + " This file is used by the error message display website and the", + true + ), + b.commentLine(" @apollo/client/includeErrors entry point.", true), + b.commentLine(" This file is not meant to be imported manually.", true), + ]; + + await eachFile(distDir, (file, relPath) => { + const source = fs.readFileSync(file, "utf8"); + const output = transform(source, relPath); + if (source !== output) { + fs.writeFileSync(file, output, "utf8"); + } + }); + + fs.writeFileSync( + osPathJoin(distDir, "invariantErrorCodes.js"), + recast.print(program, { + tabWidth: 2, + }).code + "\n" ); - return object; -} -function getErrorCode( - file: string, - expr: CallExpression | NewExpression, - type: keyof typeof allExports -): ExpressionKind { - if (isIdWithName(expr.callee, "invariant")) { - return extractString( - file, - allExports[type].properties, - expr.arguments[1], - expr.arguments[0] + function getExportObject(exportName: string) { + const object = b.objectExpression([]); + program.body.push( + b.exportNamedDeclaration( + b.variableDeclaration("const", [ + b.variableDeclarator(b.identifier(exportName), object), + ]) + ) ); - } else { - return extractString(file, allExports[type].properties, expr.arguments[0]); + return object; } - function extractString( + function getErrorCode( file: string, - target: (typeof allExports)[ExportName]["properties"], - message: recast.types.namedTypes.SpreadElement | ExpressionKind, - condition?: recast.types.namedTypes.SpreadElement | ExpressionKind + expr: CallExpression | NewExpression, + type: keyof typeof allExports ): ExpressionKind { - if (message.type === "ConditionalExpression") { - return b.conditionalExpression( - message.test, - extractString(file, target, message.consequent, condition), - extractString(file, target, message.alternate, condition) + if (isIdWithName(expr.callee, "invariant")) { + return extractString( + file, + allExports[type].properties, + expr.arguments[1], + expr.arguments[0] ); - } else if (isStringOnly(message)) { - const messageText = reprint(message); - if (messageText.includes("Apollo DevTools")) { - return message; - } + } else { + return extractString( + file, + allExports[type].properties, + expr.arguments[0] + ); + } - const obj = b.objectExpression([]); - const numLit = b.numericLiteral(nextErrorCode++); - target.push(b.property("init", numLit, obj)); + function extractString( + file: string, + target: (typeof allExports)[ExportName]["properties"], + message: recast.types.namedTypes.SpreadElement | ExpressionKind, + condition?: recast.types.namedTypes.SpreadElement | ExpressionKind + ): ExpressionKind { + if (message.type === "ConditionalExpression") { + return b.conditionalExpression( + message.test, + extractString(file, target, message.consequent, condition), + extractString(file, target, message.alternate, condition) + ); + } else if (isStringOnly(message)) { + const messageText = reprint(message); + if (messageText.includes("Apollo DevTools")) { + return message; + } + + const obj = b.objectExpression([]); + const numLit = b.numericLiteral(nextErrorCode++); + target.push(b.property("init", numLit, obj)); - obj.properties.push( - b.property( - "init", - b.identifier("file"), - b.stringLiteral("@apollo/client/" + file) - ) - ); - if (condition) { obj.properties.push( b.property( "init", - b.identifier("condition"), - b.stringLiteral(reprint(expr.arguments[0])) + b.identifier("file"), + b.stringLiteral("@apollo/client/" + file) ) ); - } - obj.properties.push(b.property("init", b.identifier("message"), message)); + if (condition) { + obj.properties.push( + b.property( + "init", + b.identifier("condition"), + b.stringLiteral(reprint(expr.arguments[0])) + ) + ); + } + obj.properties.push( + b.property("init", b.identifier("message"), message) + ); - return numLit; - } else { - throw new Error(`invariant minification error: node cannot have dynamical error argument! + return numLit; + } else { + throw new Error(`invariant minification error: node cannot have dynamical error argument! file: ${posix.join(distDir, file)}:${expr.loc?.start.line} code: ${reprint(message)} `); + } } } -} - -function transform(code: string, relativeFilePath: string) { - const ast = reparse(code); - recast.visit(ast, { - visitCallExpression(path) { - this.traverse(path); - const node = path.node; + function transform(code: string, relativeFilePath: string) { + const ast = reparse(code); - if (isCallWithLength(node, "invariant", 1)) { - const newArgs = [...node.arguments]; - newArgs.splice( - 1, - 1, - getErrorCode(relativeFilePath, node, "errorCodes") - ); - - return b.callExpression.from({ - ...node, - arguments: newArgs, - }); - } - - if (isCallWithLength(node, "newInvariantError", 0)) { - const newArgs = [...node.arguments]; - newArgs.splice( - 0, - 1, - getErrorCode(relativeFilePath, node, "errorCodes") - ); + recast.visit(ast, { + visitCallExpression(path) { + this.traverse(path); + const node = path.node; - return b.callExpression.from({ - ...node, - arguments: newArgs, - }); - } + if (isCallWithLength(node, "invariant", 1)) { + const newArgs = [...node.arguments]; + newArgs.splice( + 1, + 1, + getErrorCode(relativeFilePath, node, "errorCodes") + ); - if ( - node.callee.type === "MemberExpression" && - isIdWithName(node.callee.object, "invariant") && - isIdWithName(node.callee.property, "debug", "log", "warn", "error") - ) { - let newNode = node; - if (node.arguments[0].type !== "Identifier") { - const prop = node.callee.property; - if (!n.Identifier.check(prop)) throw new Error("unexpected type"); + return b.callExpression.from({ + ...node, + arguments: newArgs, + }); + } + if (isCallWithLength(node, "newInvariantError", 0)) { const newArgs = [...node.arguments]; newArgs.splice( 0, 1, - getErrorCode( - relativeFilePath, - node, - ("dev" + capitalize(prop.name)) as ExportName - ) + getErrorCode(relativeFilePath, node, "errorCodes") ); - newNode = b.callExpression.from({ + + return b.callExpression.from({ ...node, arguments: newArgs, }); } - if (isDEVLogicalAnd(path.parent.node)) { - return newNode; - } - return b.logicalExpression("&&", makeDEVExpr(), newNode); - } - }, - }); + if ( + node.callee.type === "MemberExpression" && + isIdWithName(node.callee.object, "invariant") && + isIdWithName(node.callee.property, "debug", "log", "warn", "error") + ) { + let newNode = node; + if (node.arguments[0].type !== "Identifier") { + const prop = node.callee.property; + if (!n.Identifier.check(prop)) throw new Error("unexpected type"); - if ( - ![ - osPathJoin("utilities", "globals", "index.js"), - osPathJoin("config", "jest", "setup.js"), - ].includes(relativeFilePath) - ) - recast.visit(ast, { - visitIdentifier(path) { - this.traverse(path); - const node = path.node; - if (isDEVExpr(node)) { - return b.binaryExpression( - "!==", - b.memberExpression( - b.identifier("globalThis"), - b.identifier("__DEV__") - ), - b.literal(false) - ); + const newArgs = [...node.arguments]; + newArgs.splice( + 0, + 1, + getErrorCode( + relativeFilePath, + node, + ("dev" + capitalize(prop.name)) as ExportName + ) + ); + newNode = b.callExpression.from({ + ...node, + arguments: newArgs, + }); + } + + if (isDEVLogicalAnd(path.parent.node)) { + return newNode; + } + return b.logicalExpression("&&", makeDEVExpr(), newNode); } - return node; }, }); - return reprint(ast); -} + if ( + ![ + osPathJoin("utilities", "globals", "index.js"), + osPathJoin("config", "jest", "setup.js"), + ].includes(relativeFilePath) + ) + recast.visit(ast, { + visitIdentifier(path) { + this.traverse(path); + const node = path.node; + if (isDEVExpr(node)) { + return b.binaryExpression( + "!==", + b.memberExpression( + b.identifier("globalThis"), + b.identifier("__DEV__") + ), + b.literal(false) + ); + } + return node; + }, + }); -function isIdWithName(node: Node | null | undefined, ...names: string[]) { - return ( - node && n.Identifier.check(node) && names.some((name) => name === node.name) - ); -} + return reprint(ast); + } -function isCallWithLength( - node: CallExpression | NewExpression, - name: string, - length: number -) { - return isIdWithName(node.callee, name) && node.arguments.length > length; -} + function isIdWithName(node: Node | null | undefined, ...names: string[]) { + return ( + node && + n.Identifier.check(node) && + names.some((name) => name === node.name) + ); + } -function isDEVLogicalAnd(node: Node) { - return ( - n.LogicalExpression.check(node) && - node.operator === "&&" && - isDEVExpr(node.left) - ); -} + function isCallWithLength( + node: CallExpression | NewExpression, + name: string, + length: number + ) { + return isIdWithName(node.callee, name) && node.arguments.length > length; + } -function makeDEVExpr() { - return b.identifier("__DEV__"); -} + function isDEVLogicalAnd(node: Node) { + return ( + n.LogicalExpression.check(node) && + node.operator === "&&" && + isDEVExpr(node.left) + ); + } -function isDEVExpr(node: Node) { - return isIdWithName(node, "__DEV__"); -} + function makeDEVExpr() { + return b.identifier("__DEV__"); + } -function isStringOnly( - node: recast.types.namedTypes.ASTNode -): node is ExpressionKind { - switch (node.type) { - case "StringLiteral": - case "Literal": - return true; - case "TemplateLiteral": - return (node.expressions as recast.types.namedTypes.ASTNode[]).every( - isStringOnly - ); - case "BinaryExpression": - return ( - node.operator == "+" && - isStringOnly(node.left) && - isStringOnly(node.right) - ); + function isDEVExpr(node: Node) { + return isIdWithName(node, "__DEV__"); } - return false; -} -function capitalize(str: string) { - return str[0].toUpperCase() + str.slice(1); + function isStringOnly( + node: recast.types.namedTypes.ASTNode + ): node is ExpressionKind { + switch (node.type) { + case "StringLiteral": + case "Literal": + return true; + case "TemplateLiteral": + return (node.expressions as recast.types.namedTypes.ASTNode[]).every( + isStringOnly + ); + case "BinaryExpression": + return ( + node.operator == "+" && + isStringOnly(node.left) && + isStringOnly(node.right) + ); + } + return false; + } + + function capitalize(str: string) { + return str[0].toUpperCase() + str.slice(1); + } } diff --git a/config/rewriteSourceMaps.ts b/config/rewriteSourceMaps.ts index 7aafafd8065..6acb7713888 100644 --- a/config/rewriteSourceMaps.ts +++ b/config/rewriteSourceMaps.ts @@ -1,48 +1,37 @@ import * as fs from "fs"; import * as path from "path"; import { distDir } from "./helpers.ts"; -import glob = require("glob"); - -glob(`${distDir.replace(/\\/g, "/")}/**/*.js.map`, (error, files) => { - if (error) throw error; +import { glob } from "node:fs/promises"; +export async function rewriteSourceMaps() { const rootDir = path.dirname(distDir); const startTime = Date.now(); let rewriteCount = 0; - Promise.all( - files.map(async (file) => { - const content = await fs.promises.readFile(file, "utf8"); - const map = JSON.parse(content); - if (map.sourcesContent) return; - if (map.sources) { - map.sourcesContent = await Promise.all( - map.sources.map((relSourcePath: string) => { - const sourcePath = path.normalize( - path.join(path.dirname(file), relSourcePath) - ); - const relPath = path.relative(rootDir, sourcePath); - // Disallow reading paths outside rootDir. - if (relPath.startsWith("../")) { - throw new Error(`Bad path: ${sourcePath}`); - } - return fs.promises.readFile(sourcePath, "utf8"); - }) - ); - ++rewriteCount; - return fs.promises.writeFile(file, JSON.stringify(map)); - } - }) - ).then( - () => { - console.log( - `Rewrote ${rewriteCount} source maps in ${Date.now() - startTime}ms` + for await (const file of glob(`${distDir.replace(/\\/g, "/")}/**/*.js.map`)) { + const content = await fs.promises.readFile(file, "utf8"); + const map = JSON.parse(content); + if (map.sourcesContent) return; + if (map.sources) { + map.sourcesContent = await Promise.all( + map.sources.map((relSourcePath: string) => { + const sourcePath = path.normalize( + path.join(path.dirname(file), relSourcePath) + ); + const relPath = path.relative(rootDir, sourcePath); + // Disallow reading paths outside rootDir. + if (relPath.startsWith("../")) { + throw new Error(`Bad path: ${sourcePath}`); + } + return fs.promises.readFile(sourcePath, "utf8"); + }) ); - }, - (error) => { - console.error(error); - process.exit(-1); + ++rewriteCount; + await fs.promises.writeFile(file, JSON.stringify(map)); } + } + console.log( + `Rewrote ${rewriteCount} source maps in ${Date.now() - startTime}ms` ); -}); +} diff --git a/config/rollup.config.js b/config/rollup.config.ts similarity index 95% rename from config/rollup.config.js rename to config/rollup.config.ts index 5ed93b35165..b89ffa5f5b2 100644 --- a/config/rollup.config.js +++ b/config/rollup.config.ts @@ -4,8 +4,9 @@ import { promises as fs } from "fs"; import nodeResolve from "@rollup/plugin-node-resolve"; import { terser as minify } from "rollup-plugin-terser"; import cleanup from "rollup-plugin-cleanup"; +import type { RollupOptions } from "rollup"; -const entryPoints = require("./entryPoints"); +import * as entryPoints from "./entryPoints.ts"; const distDir = "./dist"; const removeComments = cleanup({ @@ -55,7 +56,7 @@ function toPosixPath(p) { return p; } -function prepareCJS(input, output) { +function prepareCJS(input, output): RollupOptions { return { input, external(id, parentId) { @@ -72,7 +73,7 @@ function prepareCJS(input, output) { }; } -function prepareCJSMinified(input) { +function prepareCJSMinified(input): RollupOptions { return { input, output: { @@ -102,7 +103,7 @@ function prepareBundle({ dirs, bundleName = dirs[dirs.length - 1], extensions, -}) { +}): RollupOptions { const dir = path.join(distDir, ...dirs); const inputFile = `${dir}/index.js`; const outputFile = `${dir}/${bundleName}.cjs`; diff --git a/config/rollup.ts b/config/rollup.ts new file mode 100644 index 00000000000..a18fddfd21f --- /dev/null +++ b/config/rollup.ts @@ -0,0 +1,13 @@ +import { rollup as runRollup } from "rollup"; + +import rollupConfig from "./rollup.config.ts"; + +export async function rollup() { + for (const config of rollupConfig) { + const output = + Array.isArray(config.output) ? config.output : [config.output]; + const bundle = await runRollup(config); + await Promise.all(output.map(bundle.write)); + await bundle.close(); + } +} diff --git a/config/schema.package.json.ts b/config/schema.package.json.ts new file mode 100644 index 00000000000..3ac2403acfa --- /dev/null +++ b/config/schema.package.json.ts @@ -0,0 +1,52492 @@ +/* eslint-disable */ +/** + * This file was automatically generated by json-schema-to-typescript + * based on https://json.schemastore.org/package.json. + * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file, + * and run json-schema-to-typescript to regenerate this file. + */ + +export type JSONSchemaForNPMPackageJsonFiles = { + [k: string]: unknown; +} & { + /** + * The name of the package. + */ + name?: string; + /** + * Version must be parseable by node-semver, which is bundled with npm as a dependency. + */ + version?: string; + /** + * This helps people discover your package, as it's listed in 'npm search'. + */ + description?: string; + /** + * This helps people discover your package as it's listed in 'npm search'. + */ + keywords?: string[]; + /** + * The url to the project homepage. + */ + homepage?: string; + /** + * The url to your project's issue tracker and / or the email address to which issues should be reported. These are helpful for people who encounter issues with your package. + */ + bugs?: + | { + /** + * The url to your project's issue tracker. + */ + url?: string; + /** + * The email address to which issues should be reported. + */ + email?: string; + [k: string]: unknown; + } + | string; + /** + * You should specify a license for your package so that people know how they are permitted to use it, and any restrictions you're placing on it. + */ + license?: + | string + | ( + | "AGPL-3.0-only" + | "Apache-2.0" + | "BSD-2-Clause" + | "BSD-3-Clause" + | "BSL-1.0" + | "CC0-1.0" + | "CDDL-1.0" + | "CDDL-1.1" + | "EPL-1.0" + | "EPL-2.0" + | "GPL-2.0-only" + | "GPL-3.0-only" + | "ISC" + | "LGPL-2.0-only" + | "LGPL-2.1-only" + | "LGPL-2.1-or-later" + | "LGPL-3.0-only" + | "LGPL-3.0-or-later" + | "MIT" + | "MPL-2.0" + | "MS-PL" + | "UNLICENSED" + ); + /** + * DEPRECATED: Instead, use SPDX expressions, like this: { "license": "ISC" } or { "license": "(MIT OR Apache-2.0)" } see: 'https://docs.npmjs.com/files/package.json#license'. + */ + licenses?: { + type?: License; + url?: string; + [k: string]: unknown; + }[]; + author?: Person; + /** + * A list of people who contributed to this package. + */ + contributors?: Person[]; + /** + * A list of people who maintains this package. + */ + maintainers?: Person[]; + /** + * The 'files' field is an array of files to include in your project. If you name a folder in the array, then it will also include the files inside that folder. + */ + files?: string[]; + /** + * The main field is a module ID that is the primary entry point to your program. + */ + main?: string; + /** + * The "exports" field is used to restrict external access to non-exported module files, also enables a module to import itself using "name". + */ + exports?: + | (string | null) + | { + /** + * The module path that is resolved when the module specifier matches "name", shadows the "main" field. + */ + "."?: PackageExportsEntry | PackageExportsFallback; + /** + * The module path prefix that is resolved when the module specifier starts with "name/", set to "./*" to allow external modules to import any subpath. + * + * This interface was referenced by `undefined`'s JSON-Schema definition + * via the `patternProperty` "^\./.+". + */ + [k: string]: PackageExportsEntry | PackageExportsFallback; + } + | PackageExportsEntryObject1 + | PackageExportsFallback1; + /** + * The "imports" field is used to create private mappings that only apply to import specifiers from within the package itself. + */ + imports?: { + /** + * The module path that is resolved when this environment matches the property name. + * + * This interface was referenced by `undefined`'s JSON-Schema definition + * via the `patternProperty` "^#.+$". + */ + [k: string]: PackageImportsEntry | PackageImportsFallback; + }; + bin?: + | string + | { + [k: string]: string; + }; + /** + * When set to "module", the type field allows a package to specify all .js files within are ES modules. If the "type" field is omitted or set to "commonjs", all .js files are treated as CommonJS. + */ + type?: "commonjs" | "module"; + /** + * Set the types property to point to your bundled declaration file. + */ + types?: string; + /** + * Note that the "typings" field is synonymous with "types", and could be used as well. + */ + typings?: string; + /** + * The "typesVersions" field is used since TypeScript 3.1 to support features that were only made available in newer TypeScript versions. + */ + typesVersions?: { + /** + * Contains overrides for the TypeScript version that matches the version range matching the property key. + */ + [k: string]: { + /** + * Maps all file paths to the file paths specified in the array. + */ + "*"?: string[]; + }; + }; + /** + * Specify either a single file or an array of filenames to put in place for the man program to find. + */ + man?: string[] | string; + directories?: { + /** + * If you specify a 'bin' directory, then all the files in that folder will be used as the 'bin' hash. + */ + bin?: string; + /** + * Put markdown files in here. Eventually, these will be displayed nicely, maybe, someday. + */ + doc?: string; + /** + * Put example scripts in here. Someday, it might be exposed in some clever way. + */ + example?: string; + /** + * Tell people where the bulk of your library is. Nothing special is done with the lib folder in any way, but it's useful meta info. + */ + lib?: string; + /** + * A folder that is full of man pages. Sugar to generate a 'man' array by walking the folder. + */ + man?: string; + test?: string; + [k: string]: unknown; + }; + /** + * Specify the place where your code lives. This is helpful for people who want to contribute. + */ + repository?: + | { + type?: string; + url?: string; + directory?: string; + [k: string]: unknown; + } + | string; + funding?: + | FundingUrl + | FundingWay + | [FundingUrl | FundingWay, ...(FundingUrl | FundingWay)[]]; + /** + * The 'scripts' member is an object hash of script commands that are run at various times in the lifecycle of your package. The key is the lifecycle event, and the value is the command to run at that point. + */ + scripts?: { + /** + * Run code quality tools, e.g. ESLint, TSLint, etc. + */ + lint?: string; + /** + * Run BEFORE the package is published (Also run on local npm install without any arguments). + */ + prepublish?: string; + /** + * Run both BEFORE the package is packed and published, and on local npm install without any arguments. This is run AFTER prepublish, but BEFORE prepublishOnly. + */ + prepare?: string; + /** + * Run BEFORE the package is prepared and packed, ONLY on npm publish. + */ + prepublishOnly?: string; + /** + * run BEFORE a tarball is packed (on npm pack, npm publish, and when installing git dependencies). + */ + prepack?: string; + /** + * Run AFTER the tarball has been generated and moved to its final destination. + */ + postpack?: string; + /** + * Publishes a package to the registry so that it can be installed by name. See https://docs.npmjs.com/cli/v8/commands/npm-publish + */ + publish?: string; + postpublish?: ScriptsPublishAfter; + /** + * Run BEFORE the package is installed. + */ + preinstall?: string; + install?: ScriptsInstallAfter; + postinstall?: ScriptsInstallAfter; + preuninstall?: ScriptsUninstallBefore; + uninstall?: ScriptsUninstallBefore; + /** + * Run AFTER the package is uninstalled. + */ + postuninstall?: string; + preversion?: ScriptsVersionBefore; + version?: ScriptsVersionBefore; + /** + * Run AFTER bump the package version. + */ + postversion?: string; + pretest?: ScriptsTest; + test?: ScriptsTest; + posttest?: ScriptsTest; + prestop?: ScriptsStop; + stop?: ScriptsStop; + poststop?: ScriptsStop; + prestart?: ScriptsStart; + start?: ScriptsStart; + poststart?: ScriptsStart; + prerestart?: ScriptsRestart; + restart?: ScriptsRestart; + postrestart?: ScriptsRestart; + /** + * Start dev server to serve application files + */ + serve?: string; + [k: string]: string | undefined; + }; + /** + * A 'config' hash can be used to set configuration parameters used in package scripts that persist across upgrades. + */ + config?: { + [k: string]: unknown; + }; + dependencies?: Dependency; + devDependencies?: Dependency; + optionalDependencies?: Dependency; + peerDependencies?: Dependency; + peerDependenciesMeta?: PeerDependencyMeta; + /** + * Array of package names that will be bundled when publishing the package. + */ + bundleDependencies?: string[] | boolean; + /** + * DEPRECATED: This field is honored, but "bundleDependencies" is the correct field name. + */ + bundledDependencies?: string[] | boolean; + /** + * Resolutions is used to support selective version resolutions using yarn, which lets you define custom package versions or ranges inside your dependencies. For npm, use overrides instead. See: https://classic.yarnpkg.com/en/docs/selective-version-resolutions + */ + resolutions?: { + [k: string]: unknown; + }; + /** + * Overrides is used to support selective version overrides using npm, which lets you define custom package versions or ranges inside your dependencies. For yarn, use resolutions instead. See: https://docs.npmjs.com/cli/v9/configuring-npm/package-json#overrides + */ + overrides?: { + [k: string]: unknown; + }; + /** + * Defines which package manager is expected to be used when working on the current project. This field is currently experimental and needs to be opted-in; see https://nodejs.org/api/corepack.html + */ + packageManager?: string; + engines?: { + node?: string; + [k: string]: string; + }; + /** + * Defines which tools and versions are expected to be used when Volta is installed. + */ + volta?: { + /** + * The value of that entry should be a path to another JSON file which also has a "volta" section + */ + extends?: string; + /** + * This interface was referenced by `undefined`'s JSON-Schema definition + * via the `patternProperty` "(node|npm|pnpm|yarn)". + */ + [k: string]: string; + }; + engineStrict?: boolean; + /** + * Specify which operating systems your module will run on. + */ + os?: string[]; + /** + * Specify that your code only runs on certain cpu architectures. + */ + cpu?: string[]; + /** + * DEPRECATED: This option used to trigger an npm warning, but it will no longer warn. It is purely there for informational purposes. It is now recommended that you install any binaries as local devDependencies wherever possible. + */ + preferGlobal?: boolean; + /** + * If set to true, then npm will refuse to publish it. + */ + private?: boolean | ("false" | "true"); + publishConfig?: { + access?: "public" | "restricted"; + tag?: string; + registry?: string; + provenance?: boolean; + [k: string]: unknown; + }; + dist?: { + shasum?: string; + tarball?: string; + [k: string]: unknown; + }; + readme?: string; + /** + * An ECMAScript module ID that is the primary entry point to your program. + */ + module?: string; + /** + * A module ID with untranspiled code that is the primary entry point to your program. + */ + esnext?: + | string + | { + main?: string; + browser?: string; + [k: string]: string; + }; + /** + * Allows packages within a directory to depend on one another using direct linking of local files. Additionally, dependencies within a workspace are hoisted to the workspace root when possible to reduce duplication. Note: It's also a good idea to set "private" to true when using this feature. + */ + workspaces?: + | string[] + | { + /** + * Workspace package paths. Glob patterns are supported. + */ + packages?: string[]; + /** + * Packages to block from hoisting to the workspace root. Currently only supported in Yarn only. + */ + nohoist?: string[]; + [k: string]: unknown; + }; + jspm?: JSONSchemaForNPMPackageJsonFiles; + eslintConfig?: JSONSchemaForESLintConfigurationFiles; + prettier?: SchemaForPrettierrc; + stylelint?: JSONSchemaForTheStylelintConfigurationFiles; + ava?: AVAConfigSchema; + release?: SemanticReleaseSchema; + jscpd?: HttpsJsonSchemastoreOrgJscpdJson; + /** + * Defines pnpm specific configuration. + */ + pnpm?: { + /** + * Used to override any dependency in the dependency graph. + */ + overrides?: { + [k: string]: unknown; + }; + /** + * Used to extend the existing package definitions with additional information. + */ + packageExtensions?: { + /** + * This interface was referenced by `undefined`'s JSON-Schema definition + * via the `patternProperty` "^.+$". + */ + [k: string]: { + dependencies?: Dependency; + optionalDependencies?: Dependency; + peerDependencies?: Dependency; + peerDependenciesMeta?: PeerDependencyMeta; + }; + }; + peerDependencyRules?: { + /** + * pnpm will not print warnings about missing peer dependencies from this list. + */ + ignoreMissing?: string[]; + /** + * Unmet peer dependency warnings will not be printed for peer dependencies of the specified range. + */ + allowedVersions?: { + [k: string]: unknown; + }; + /** + * Any peer dependency matching the pattern will be resolved from any version, regardless of the range specified in "peerDependencies". + */ + allowAny?: string[]; + }; + /** + * A list of dependencies to skip the builds. + */ + neverBuiltDependencies?: string[]; + /** + * A list of dependencies to skip the builds. + */ + onlyBuiltDependencies?: string[]; + /** + * Specifies a JSON file that lists the only packages permitted to run installation scripts during the pnpm install process. + */ + onlyBuiltDependenciesFile?: string; + /** + * A list of deprecated versions that the warnings are suppressed. + */ + allowedDeprecatedVersions?: { + [k: string]: unknown; + }; + /** + * A list of dependencies that are patched. + */ + patchedDependencies?: { + [k: string]: unknown; + }; + /** + * When true, installation won't fail if some of the patches from the "patchedDependencies" field were not applied. + */ + allowNonAppliedPatches?: boolean; + updateConfig?: { + /** + * A list of packages that should be ignored when running "pnpm outdated" or "pnpm update --latest". + */ + ignoreDependencies?: string[]; + }; + auditConfig?: { + /** + * A list of CVE IDs that will be ignored by "pnpm audit". + */ + ignoreCves?: string[]; + /** + * A list of GHSA Codes that will be ignored by "pnpm audit". + */ + ignoreGhsas?: string[]; + }; + /** + * A list of scripts that must exist in each project. + */ + requiredScripts?: string[]; + /** + * Specifies architectures for which you'd like to install optional dependencies, even if they don't match the architecture of the system running the install. + */ + supportedArchitectures?: { + os?: string[]; + cpu?: string[]; + libc?: string[]; + }; + /** + * A list of optional dependencies that the install should be skipped. + */ + ignoredOptionalDependencies?: string[]; + executionEnv?: { + /** + * Specifies which exact Node.js version should be used for the project's runtime. + */ + nodeVersion?: string; + }; + }; + /** + * Any property starting with _ is valid. + * + * This interface was referenced by `undefined`'s JSON-Schema definition + * via the `patternProperty` "^_". + */ + [k: string]: any; +}; +export type License = + | string + | ( + | "AGPL-3.0-only" + | "Apache-2.0" + | "BSD-2-Clause" + | "BSD-3-Clause" + | "BSL-1.0" + | "CC0-1.0" + | "CDDL-1.0" + | "CDDL-1.1" + | "EPL-1.0" + | "EPL-2.0" + | "GPL-2.0-only" + | "GPL-3.0-only" + | "ISC" + | "LGPL-2.0-only" + | "LGPL-2.1-only" + | "LGPL-2.1-or-later" + | "LGPL-3.0-only" + | "LGPL-3.0-or-later" + | "MIT" + | "MPL-2.0" + | "MS-PL" + | "UNLICENSED" + ); +/** + * A person who has been involved in creating or maintaining this package. + */ +export type Person = { + name: string; + url?: string; + email?: string; + [k: string]: unknown; +} & Person1; +export type Person1 = + | { + name: string; + url?: string; + email?: string; + [k: string]: unknown; + } + | string; +export type PackageExportsEntry = + | PackageExportsEntryPath + | PackageExportsEntryObject; +/** + * The module path that is resolved when this specifier is imported. Set to `null` to disallow importing this module. + */ +export type PackageExportsEntryPath = string | null; +/** + * Used to allow fallbacks in case this environment doesn't support the preceding entries. + */ +export type PackageExportsFallback = PackageExportsEntry[]; +/** + * Used to allow fallbacks in case this environment doesn't support the preceding entries. + */ +export type PackageExportsFallback1 = PackageExportsEntry[]; +export type PackageImportsEntry = + | PackageImportsEntryPath + | PackageImportsEntryObject; +/** + * The module path that is resolved when this specifier is imported. Set to `null` to disallow importing this module. + */ +export type PackageImportsEntryPath = string | null; +/** + * Used to allow fallbacks in case this environment doesn't support the preceding entries. + */ +export type PackageImportsFallback = PackageImportsEntry[]; +/** + * URL to a website with details about how to fund the package. + */ +export type FundingUrl = string; +/** + * Run AFTER the package is published. + */ +export type ScriptsPublishAfter = string; +/** + * Run AFTER the package is installed. + */ +export type ScriptsInstallAfter = string; +/** + * Run BEFORE the package is uninstalled. + */ +export type ScriptsUninstallBefore = string; +/** + * Run BEFORE bump the package version. + */ +export type ScriptsVersionBefore = string; +/** + * Run by the 'npm test' command. + */ +export type ScriptsTest = string; +/** + * Run by the 'npm stop' command. + */ +export type ScriptsStop = string; +/** + * Run by the 'npm start' command. + */ +export type ScriptsStart = string; +/** + * Run by the 'npm restart' command. Note: 'npm restart' will run the stop and start scripts if no restart script is provided. + */ +export type ScriptsRestart = string; +/** + * ESLint supports the use of third-party plugins. Before using the plugin, you have to install it using npm. + */ +export type Plugins = string[]; +/** + * ESLint comes with a large number of rules. You can modify which rules your project uses either using configuration comments or configuration files. + */ +export type Rules = PossibleErrors & + BestPractices & + StrictMode & + Variables & + NodeAndCommonJs & + StylisticIssues & + EcmaScript6 & + Legacy & + HttpsJsonSchemastoreOrgPartialEslintPluginsJson; +/** + * Allows to override configuration for files and folders, specified by glob patterns + */ +export type Overrides = { + /** + * Glob pattern for files to apply 'overrides' configuration, relative to the directory of the config file + */ + files: string | [string, ...string[]]; + /** + * If you want to extend a specific configuration file, you can use the extends property and specify the path to the file. The path can be either relative or absolute. + */ + extends?: string | string[]; + /** + * If a file matches any of the 'excludedFiles' glob patterns, the 'overrides' configuration won't apply + */ + excludedFiles?: string | string[]; + ecmaFeatures?: EcmaFeatures; + env?: Env; + globals?: Globals; + parser?: string; + parserOptions?: ParserOptions; + plugins?: Plugins; + /** + * To specify a processor, specify the plugin name and processor name joined by a forward slash + */ + processor?: string; + rules?: Rules; + settings?: Settings; + overrides?: Overrides; +}[]; +export type SchemaForPrettierrc = + | (OptionsDefinition & OverridesDefinition) + | string; +/** + * Your configuration can extend an existing configuration(s) (whether your own or a third-party config) + */ +export type SimpleStringOrArrayStringRule = (string | SimpleArrayStringRule) & + ( + | ((string | SimpleArrayStringRule) & string) + | ((string | SimpleArrayStringRule) & unknown[]) + ); +export type SimpleArrayStringRule = string[]; +/** + * Plugins are rules or sets of rules built by the community that support methodologies, toolsets, non-standard CSS features, or very specific use cases + */ +export type SimpleArrayStringRule1 = string[]; +export type AllRules = AtRule & + Block & + Color & + Comment & + CustomMedia & + CustomProperty & + Declaration & + DeclarationBlock & + Font & + Function & + GeneralSheet & + KeyframeDeclaration & + Length & + Lightness & + MediaFeature & + MediaQuery & + MediaQueryList & + Number & + Property & + RootRule & + Rule & + Selector & + SelectorList & + ShorthandProperty & + String & + StylelintDisableComment & + Time & + Unit & + Value & + ValueList; +/** + * Specify a blacklist of disallowed at-rules + */ +export type ArrayStringRule = ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] +) & + ( + | (null & + ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + )) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + string) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + unknown[]) + ); +/** + * Specify lowercase or uppercase for at-rules names + */ +export type LowerUpperRule = ( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Require a newline after at-rule names + */ +export type AlwaysMultiLineRule = ( + | null + | ("always" | "always-multi-line" | []) + | [ + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ) & + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ), + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ) & + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "always-multi-line" | []) + | [ + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & + string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ) & + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & + string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ), + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & + string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ) & + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & + string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "always-multi-line" | []) + | [ + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ) & + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ), + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ) & + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "always-multi-line" | []) + | [ + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ) & + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ), + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ) & + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Disallow vendor prefixes for at-rules + */ +export type BooleanRule = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Specify a whitelist of allowed at-rules + */ +export type ArrayStringRule1 = ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] +) & + ( + | (null & + ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + )) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + string) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + unknown[]) + ); +/** + * Require a newline or disallow whitespace after the closing brace of blocks + */ +export type NewlineSpaceWithIgnoreRule = ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a newline or disallow whitespace before the closing brace of blocks + */ +export type NewlineRule = ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace after the closing brace of blocks + */ +export type NewlineSpaceRule = ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace before the closing brace of blocks + */ +export type NewlineSpaceRule1 = ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Disallow empty blocks + */ +export type BooleanRule1 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow single-line blocks + */ +export type BooleanRule2 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Require a newline after the opening brace of blocks + */ +export type NewlineRule1 = ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace after the opening brace of blocks + */ +export type NewlineSpaceRule2 = ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace before the opening brace of blocks + */ +export type NewlineSpaceWithIgnoreRule1 = ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | [] + ) + | [ + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-single-line" + | "never-single-line" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Specify lowercase or uppercase for hex colors + */ +export type LowerUpperRule1 = ( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Disallow hex colors + */ +export type BooleanRule3 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow invalid hex colors + */ +export type BooleanRule4 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow empty comments + */ +export type BooleanRule5 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Require or disallow whitespace on the inside of comment markers + */ +export type AlwaysNeverRule = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Specify a blacklist of disallowed words within comments + */ +export type ArrayStringRule2 = ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] +) & + ( + | (null & + ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + )) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + string) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + unknown[]) + ); +/** + * Specify a pattern for custom media query names + */ +export type StringRule = ( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] +) & + ( + | (null & + ( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] + )) + | (( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] + ) & + string) + | (( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow custom properties outside of `:root` rules + */ +export type BooleanRule6 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Specify a pattern for custom properties + */ +export type StringRule1 = ( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] +) & + ( + | (null & + ( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] + )) + | (( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] + ) & + string) + | (( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace after the bang of declarations + */ +export type AlwaysNeverRule1 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace before the bang of declarations + */ +export type AlwaysNeverRule2 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Require a newline or disallow whitespace after the colon of declarations + */ +export type AlwaysMultiLineRule1 = ( + | null + | ("always" | "always-multi-line" | []) + | [ + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ) & + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ), + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ) & + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "always-multi-line" | []) + | [ + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & + string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ) & + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & + string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ), + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & + string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ) & + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & + string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "always-multi-line" | []) + | [ + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ) & + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ), + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ) & + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "always-multi-line" | []) + | [ + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ) & + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ), + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ) & + (("always" | "always-multi-line" | {}) | CoreRule) & + ( + | ((("always" | "always-multi-line" | {}) | CoreRule) & string) + | (("always" | "always-multi-line" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace before the colon of declarations + */ +export type AlwaysNeverRule3 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Disallow `!important` within declarations + */ +export type BooleanRule7 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +export type SimpleStringOrArrayStringRule1 = (string | SimpleArrayStringRule) & + ( + | ((string | SimpleArrayStringRule) & string) + | ((string | SimpleArrayStringRule) & unknown[]) + ); +/** + * Disallow property values that are ignored due to another property value in the same rule + */ +export type BooleanRule8 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow shorthand properties that override related longhand properties + */ +export type BooleanRule9 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Require a newline or disallow whitespace after the semicolons of declaration blocks + */ +export type NewlineRule2 = ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a newline or disallow whitespace before the semicolons of declaration blocks + */ +export type NewlineRule3 = ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace after the semicolons of declaration blocks + */ +export type SpaceRule = ( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace before the semicolons of declaration blocks + */ +export type SpaceRule1 = ( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Limit the number of declaration within a single line declaration block + */ +export type IntegerRule = ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] +) & + ( + | (null & + ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + )) + | (number & + ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + )) + | (( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Require or disallow a trailing semicolon within declaration blocks + */ +export type AlwaysNeverRule4 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Specify a blacklist of disallowed functions + */ +export type ArrayStringRule3 = ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] +) & + ( + | (null & + ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + )) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + string) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + unknown[]) + ); +/** + * Disallow an unspaced operator within `calc` functions + */ +export type BooleanRule10 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Require a newline or disallow whitespace after the commas of functions + */ +export type NewlineRule4 = ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a newline or disallow whitespace before the commas of functions + */ +export type NewlineRule5 = ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace after the commas of functions + */ +export type SpaceRule2 = ( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace before the commas of functions + */ +export type SpaceRule3 = ( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Disallow direction values in `linear-gradient()` calls that are not valid according to the standard syntax + */ +export type BooleanRule11 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Limit the number of adjacent empty lines within functions + */ +export type IntegerRule1 = ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] +) & + ( + | (null & + ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + )) + | (number & + ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + )) + | (( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Require a newline or disallow whitespace on the inside of the parentheses of functions + */ +export type NewlineRule6 = ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace on the inside of the parentheses of functions + */ +export type SpaceRule4 = ( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require or disallow data URIs for urls + */ +export type AlwaysNeverRule5 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Disallow scheme-relative urls + */ +export type BooleanRule12 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Require or disallow quotes for urls + */ +export type AlwaysNeverRule6 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Specify a whitelist of allowed url schemes + */ +export type ArrayStringRule4 = ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] +) & + ( + | (null & + ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + )) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + string) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + unknown[]) + ); +/** + * Specify a whitelist of allowed functions + */ +export type ArrayStringRule5 = ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] +) & + ( + | (null & + ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + )) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + string) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + unknown[]) + ); +/** + * Require or disallow whitespace after functions + */ +export type AlwaysNeverRule7 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Limit the number of adjacent empty lines + */ +export type IntegerRule2 = ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] +) & + ( + | (null & + ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + )) + | (number & + ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + )) + | (( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow selectors of lower specificity from coming after overriding selectors of higher specificity + */ +export type BooleanRule13 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow duplicate selectors within a stylesheet + */ +export type BooleanRule14 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow empty sources + */ +export type BooleanRule15 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow extra semicolons + */ +export type BooleanRule16 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow double-slash comments `(//...)` which are not supported by CSS and could lead to unexpected results + */ +export type BooleanRule17 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow missing end-of-source newlines + */ +export type BooleanRule18 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow animation names that do not correspond to a `@keyframes` declaration + */ +export type BooleanRule19 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Require or disallow Unicode BOM + */ +export type AlwaysNeverRule8 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Disallow !important within keyframe declarations + */ +export type BooleanRule20 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow units for zero lengths + */ +export type BooleanRule21 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace after the colon in media features + */ +export type AlwaysNeverRule9 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace before the colon in media features + */ +export type AlwaysNeverRule10 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Specify lowercase or uppercase for media feature names + */ +export type LowerUpperRule2 = ( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Disallow vendor prefixes for media feature names + */ +export type BooleanRule22 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow missing punctuation for non-boolean media features + */ +export type BooleanRule23 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace on the inside of the parentheses within media features + */ +export type AlwaysNeverRule11 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace after the range operator in media features + */ +export type AlwaysNeverRule12 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace before the range operator in media features + */ +export type AlwaysNeverRule13 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Require a newline or disallow whitespace after the commas of media query lists + */ +export type NewlineRule7 = ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a newline or disallow whitespace before the commas of media query lists + */ +export type NewlineRule8 = ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace after the commas of media query lists + */ +export type SpaceRule5 = ( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace before the commas of media query lists + */ +export type SpaceRule6 = ( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require or disallow a leading zero for fractional numbers less than 1 + */ +export type AlwaysNeverRule14 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Limit the number of decimal places allowed in numbers + */ +export type IntegerRule3 = ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] +) & + ( + | (null & + ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + )) + | (number & + ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + )) + | (( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow trailing zeros in numbers + */ +export type BooleanRule24 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Specify a blacklist of disallowed properties + */ +export type ArrayStringRule6 = ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] +) & + ( + | (null & + ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + )) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + string) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + unknown[]) + ); +/** + * Specify lowercase or uppercase for properties + */ +export type LowerUpperRule3 = ( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Disallow vendor prefixes for properties + */ +export type BooleanRule25 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Specify a whitelist of allowed properties + */ +export type ArrayStringRule7 = ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] +) & + ( + | (null & + ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + )) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + string) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + unknown[]) + ); +/** + * Disallow standard properties inside `:root` rules + */ +export type BooleanRule26 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace on the inside of the brackets within attribute selector + */ +export type AlwaysNeverRule15 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Specify a blacklist of disallowed attribute operators + */ +export type ArrayStringRule8 = ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] +) & + ( + | (null & + ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + )) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + string) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace after operators within attribute selectors + */ +export type AlwaysNeverRule16 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace before operators within attribute selectors + */ +export type AlwaysNeverRule17 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Specify a whitelist of allowed attribute operators + */ +export type ArrayStringRule9 = ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] +) & + ( + | (null & + ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + )) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + string) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + unknown[]) + ); +/** + * Require or disallow quotes for attribute values + */ +export type AlwaysNeverRule18 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace after the combinators of selectors + */ +export type AlwaysNeverRule19 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace before the combinators of selectors + */ +export type AlwaysNeverRule20 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Disallow non-space characters for descendant combinators of selectors + */ +export type BooleanRule27 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Specify a pattern for id selectors + */ +export type StringRule2 = ( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] +) & + ( + | (null & + ( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] + )) + | (( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] + ) & + string) + | (( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Limit the number of compound selectors in a selector + */ +export type IntegerRule4 = ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] +) & + ( + | (null & + ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + )) + | (number & + ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + )) + | (( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Limit the specificity of selectors + */ +export type StringRule3 = ( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] +) & + ( + | (null & + ( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] + )) + | (( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] + ) & + string) + | (( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Specify a pattern for the selectors of rules nested within rules + */ +export type StringRule4 = ( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] +) & + ( + | (null & + ( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] + )) + | (( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] + ) & + string) + | (( + | (null | string) + | [ + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)) & + (string | CoreRule) & + (((string | CoreRule) & string) | (string | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow attribute selectors + */ +export type BooleanRule28 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow combinators in selectors + */ +export type BooleanRule29 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow id selectors + */ +export type BooleanRule30 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow the universal selector + */ +export type BooleanRule31 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow vendor prefixes for selectors + */ +export type BooleanRule32 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Specify lowercase or uppercase for pseudo-class selectors + */ +export type LowerUpperRule4 = ( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace on the inside of the parentheses within pseudo-class selectors + */ +export type AlwaysNeverRule21 = ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | []) + | [ + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ) & + (("always" | "never" | {}) | CoreRule) & + ( + | ((("always" | "never" | {}) | CoreRule) & string) + | (("always" | "never" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Specify a whitelist of allowed pseudo-class selectors + */ +export type ArrayStringRule10 = ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] +) & + ( + | (null & + ( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + )) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + string) + | (( + | (null | string) + | [ + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ), + ...((([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ) & + (([] | {}) | SimpleArrayStringRule | CoreRule) & + ( + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & string) + | ((([] | {}) | SimpleArrayStringRule | CoreRule) & unknown[]) + | (([] | {}) | SimpleArrayStringRule | CoreRule) + ))[], + ] + ) & + unknown[]) + ); +/** + * Specify lowercase or uppercase for pseudo-element selectors + */ +export type LowerUpperRule5 = ( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Specify single or double colon notation for applicable pseudo-elements + */ +export type SingleDoubleRule = ( + | null + | ("single" | "double" | []) + | [ + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ) & + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ), + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ) & + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("single" | "double" | []) + | [ + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ) & + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ), + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ) & + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("single" | "double" | []) + | [ + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ) & + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ), + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ) & + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("single" | "double" | []) + | [ + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ) & + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ), + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ) & + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Disallow the composition of :root in selectors + */ +export type BooleanRule33 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Specify lowercase or uppercase for type selectors + */ +export type LowerUpperRule6 = ( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Limit the number of adjacent empty lines within selectors + */ +export type IntegerRule5 = ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] +) & + ( + | (null & + ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + )) + | (number & + ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + )) + | (( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Require a newline or disallow whitespace after the commas of selector lists + */ +export type NewlineRule9 = ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a newline or disallow whitespace before the commas of selector lists + */ +export type NewlineRule10 = ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace after the commas of selector lists + */ +export type SpaceRule7 = ( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace before the commas of selector lists + */ +export type SpaceRule8 = ( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Disallow redundant values in shorthand properties + */ +export type BooleanRule34 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Disallow (unescaped) newlines in strings + */ +export type BooleanRule35 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Specify single or double quotes around strings + */ +export type SingleDoubleRule1 = ( + | null + | ("single" | "double" | []) + | [ + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ) & + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ), + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ) & + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("single" | "double" | []) + | [ + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ) & + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ), + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ) & + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("single" | "double" | []) + | [ + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ) & + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ), + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ) & + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("single" | "double" | []) + | [ + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ) & + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ), + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ) & + (("single" | "double" | {}) | CoreRule) & + ( + | ((("single" | "double" | {}) | CoreRule) & string) + | (("single" | "double" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Disallow `animation` and `transition` less than or equal to 100ms + */ +export type BooleanRule36 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Specify a blacklist of disallowed units + */ +export type UnitRule = ( + | null + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + ) + | [ + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ) & + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ), + ...(( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ) & + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ))[], + ] +) & + ( + | (null & + ( + | null + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + ) + | [ + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ) & + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ), + ...(( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ) & + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ))[], + ] + )) + | (( + | null + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + ) + | [ + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ) & + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ), + ...(( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ) & + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ))[], + ] + ) & + string) + | (( + | null + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + ) + | [ + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ) & + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ), + ...(( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ) & + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ))[], + ] + ) & + unknown[]) + ); +/** + * Specify lowercase or uppercase for units + */ +export type LowerUpperRule7 = ( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] +) & + ( + | (null & + ( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + )) + | (( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + ) & + string) + | (( + | null + | ("lower" | "upper" | []) + | [ + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ) & + (("lower" | "upper" | {}) | CoreRule) & + ( + | ((("lower" | "upper" | {}) | CoreRule) & string) + | (("lower" | "upper" | {}) | CoreRule) + ), + ] + ) & + unknown[]) + ); +/** + * Specify a whitelist of allowed units + */ +export type UnitRule1 = ( + | null + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + ) + | [ + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ) & + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ), + ...(( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ) & + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ))[], + ] +) & + ( + | (null & + ( + | null + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + ) + | [ + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ) & + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ), + ...(( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ) & + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ))[], + ] + )) + | (( + | null + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + ) + | [ + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ) & + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ), + ...(( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ) & + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ))[], + ] + ) & + string) + | (( + | null + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + ) + | [ + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ) & + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ), + ...(( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ) & + ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + ( + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + string) + | (( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) & + unknown[]) + | ( + | ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + | [] + | {} + ) + | [ + ( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + ), + ...( + | "em" + | "ex" + | "px" + | "%" + | "rem" + | "vw" + | "vh" + | "vm" + | "vmin" + | "vmax" + | "ch" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "deg" + | "grad" + | "rad" + | "turn" + | "ms" + | "s" + | "Hz" + | "kHz" + | "dpi" + | "dpcm" + | "dppx" + | "fr" + )[], + ] + | CoreRule + ) + ))[], + ] + ) & + unknown[]) + ); +/** + * Disallow vendor prefixes for values + */ +export type BooleanRule37 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Require a newline or disallow whitespace after the commas of value lists + */ +export type NewlineRule11 = ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a newline or disallow whitespace before the commas of value lists + */ +export type NewlineRule12 = ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + (("always" | "always-multi-line" | "never-multi-line" | {}) | CoreRule) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "always-multi-line" + | "never-multi-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "always-multi-line" | "never-multi-line" | []) + | [ + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ) & + ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + ( + | (( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) & + string) + | ( + | ("always" | "always-multi-line" | "never-multi-line" | {}) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace after the commas of value lists + */ +export type SpaceRule9 = ( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Require a single space or disallow whitespace before the commas of value lists + */ +export type SpaceRule10 = ( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ("always" | "never" | "always-single-line" | "never-single-line" | {}) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] +) & + ( + | (null & + ( + | null + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | [] + ) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + )) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + string) + | (( + | null + | ("always" | "never" | "always-single-line" | "never-single-line" | []) + | [ + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ) & + ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + ( + | (( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) & + string) + | ( + | ( + | "always" + | "never" + | "always-single-line" + | "never-single-line" + | {} + ) + | CoreRule + ) + ), + ] + ) & + unknown[]) + ); +/** + * Limit the number of adjacent empty lines within value lists + */ +export type IntegerRule6 = ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] +) & + ( + | (null & + ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + )) + | (number & + ( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + )) + | (( + | (null | number) + | [ + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)) & + ({} | CoreRule) & + ((({} | CoreRule) & number) | ({} | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Provide a glob or array of globs to ignore specific files + */ +export type SimpleStringOrArrayStringRule2 = (string | SimpleArrayStringRule) & + ( + | ((string | SimpleArrayStringRule) & string) + | ((string | SimpleArrayStringRule) & unknown[]) + ); +/** + * Report stylelint-disable comments without a description. + */ +export type BooleanRule38 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Report stylelint-disable comments that don't match rules that are specified in the configuration object. + */ +export type BooleanRule39 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * Report stylelint-disable comments that don't actually match any lints that need to be disabled + */ +export type BooleanRule40 = ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] +) & + ( + | (null & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (boolean & + ( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + )) + | (( + | null + | boolean + | [ + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)) & + (boolean | CoreRule) & + (((boolean | CoreRule) & boolean) | (boolean | CoreRule)), + ] + ) & + unknown[]) + ); +/** + * An array of glob patterns to select test files. Files with an underscore prefix are ignored. By default only selects files with `cjs`, `mjs` & `js` extensions, even if the pattern matches other files. Specify `extensions` to allow other file extensions + */ +export type ArrayOfPaths = string[]; +/** + * An array of glob patterns to match files that, even if changed, are ignored by the watcher + */ +export type ArrayOfPaths1 = string[]; +/** + * Not typically useful in the `package.json` configuration, but equivalent to specifying `--match` on the CLI + */ +export type ArrayOfPaths2 = string[]; +export type ArrayOfStrings = string[]; +/** + * Extra modules to require before tests are run. Modules are required in the worker processes + */ +export type ArrayOfPaths3 = string[]; +/** + * Configure Node.js arguments used to launch worker processes + */ +export type ArrayOfStrings1 = string[]; +/** + * You can configure AVA to recognize additional file extensions as TypeScript (e.g., `["ts", "tsx"]` to add partial JSX support). Note that the preserve mode for JSX is not (yet) supported. See also AVA's `extensions` object + */ +export type ArrayOfPaths4 = string[]; + +/** + * Used to specify conditional exports, note that Conditional exports are unsupported in older environments, so it's recommended to use the fallback array option if support for those environments is a concern. + */ +export interface PackageExportsEntryObject { + /** + * The module path that is resolved when this specifier is imported as a CommonJS module using the `require(...)` function. + */ + require?: PackageExportsEntry | PackageExportsFallback; + /** + * The module path that is resolved when this specifier is imported as an ECMAScript module using an `import` declaration or the dynamic `import(...)` function. + */ + import?: PackageExportsEntry | PackageExportsFallback; + /** + * The module path that is resolved when this environment is Node.js. + */ + node?: PackageExportsEntry | PackageExportsFallback; + /** + * The module path that is resolved when no other export type matches. + */ + default?: PackageExportsEntry | PackageExportsFallback; + /** + * The module path that is resolved for TypeScript types when this specifier is imported. Should be listed before other conditions. + */ + types?: PackageExportsEntry | PackageExportsFallback; + /** + * The module path that is resolved when this environment matches the property name. + * + * This interface was referenced by `PackageExportsEntryObject`'s JSON-Schema definition + * via the `patternProperty` "^[^.0-9]+$". + * + * This interface was referenced by `PackageExportsEntryObject1`'s JSON-Schema definition + * via the `patternProperty` "^[^.0-9]+$". + */ + [k: string]: PackageExportsEntry | PackageExportsFallback; +} +/** + * The module path that is resolved when the module specifier matches "name", shadows the "main" field. + */ +export interface PackageExportsEntryObject1 { + /** + * The module path that is resolved when this specifier is imported as a CommonJS module using the `require(...)` function. + */ + require?: PackageExportsEntry | PackageExportsFallback; + /** + * The module path that is resolved when this specifier is imported as an ECMAScript module using an `import` declaration or the dynamic `import(...)` function. + */ + import?: PackageExportsEntry | PackageExportsFallback; + /** + * The module path that is resolved when this environment is Node.js. + */ + node?: PackageExportsEntry | PackageExportsFallback; + /** + * The module path that is resolved when no other export type matches. + */ + default?: PackageExportsEntry | PackageExportsFallback; + /** + * The module path that is resolved for TypeScript types when this specifier is imported. Should be listed before other conditions. + */ + types?: PackageExportsEntry | PackageExportsFallback; + /** + * The module path that is resolved when this environment matches the property name. + * + * This interface was referenced by `PackageExportsEntryObject`'s JSON-Schema definition + * via the `patternProperty` "^[^.0-9]+$". + * + * This interface was referenced by `PackageExportsEntryObject1`'s JSON-Schema definition + * via the `patternProperty` "^[^.0-9]+$". + */ + [k: string]: PackageExportsEntry | PackageExportsFallback; +} +/** + * Used to specify conditional exports, note that Conditional exports are unsupported in older environments, so it's recommended to use the fallback array option if support for those environments is a concern. + */ +export interface PackageImportsEntryObject { + /** + * The module path that is resolved when this specifier is imported as a CommonJS module using the `require(...)` function. + */ + require?: PackageImportsEntry | PackageImportsFallback; + /** + * The module path that is resolved when this specifier is imported as an ECMAScript module using an `import` declaration or the dynamic `import(...)` function. + */ + import?: PackageImportsEntry | PackageImportsFallback; + /** + * The module path that is resolved when this environment is Node.js. + */ + node?: PackageImportsEntry | PackageImportsFallback; + /** + * The module path that is resolved when no other export type matches. + */ + default?: PackageImportsEntry | PackageImportsFallback; + /** + * The module path that is resolved for TypeScript types when this specifier is imported. Should be listed before other conditions. + */ + types?: PackageImportsEntry | PackageImportsFallback; + /** + * The module path that is resolved when this environment matches the property name. + * + * This interface was referenced by `PackageImportsEntryObject`'s JSON-Schema definition + * via the `patternProperty` "^[^.0-9]+$". + */ + [k: string]: PackageImportsEntry | PackageImportsFallback; +} +/** + * Used to inform about ways to help fund development of the package. + */ +export interface FundingWay { + url: FundingUrl; + /** + * The type of funding or the platform through which funding can be provided, e.g. patreon, opencollective, tidelift or github. + */ + type?: string; +} +/** + * Dependencies are specified with a simple hash of package name to version range. The version range is a string which has one or more space-separated descriptors. Dependencies can also be identified with a tarball or git URL. + */ +export interface Dependency { + [k: string]: string; +} +/** + * When a user installs your package, warnings are emitted if packages specified in "peerDependencies" are not already installed. The "peerDependenciesMeta" field serves to provide more information on how your peer dependencies are utilized. Most commonly, it allows peer dependencies to be marked as optional. Metadata for this field is specified with a simple hash of the package name to a metadata object. + */ +export interface PeerDependencyMeta { + [k: string]: { + /** + * Specifies that this peer dependency is optional and should not be installed automatically. + */ + optional?: boolean; + [k: string]: unknown; + }; +} +export interface JSONSchemaForESLintConfigurationFiles { + ecmaFeatures?: EcmaFeatures; + env?: Env; + /** + * If you want to extend a specific configuration file, you can use the extends property and specify the path to the file. The path can be either relative or absolute. + */ + extends?: string | string[]; + globals?: Globals; + /** + * Prevent comments from changing config or rules + */ + noInlineConfig?: boolean; + /** + * Report unused eslint-disable comments + */ + reportUnusedDisableDirectives?: boolean; + parser?: string; + parserOptions?: ParserOptions; + plugins?: Plugins; + /** + * By default, ESLint will look for configuration files in all parent folders up to the root directory. This can be useful if you want all of your projects to follow a certain convention, but can sometimes lead to unexpected results. To limit ESLint to a specific project, set this to `true` in a configuration in the root of your project. + */ + root?: boolean; + /** + * Tell ESLint to ignore specific files and directories. Each value uses the same pattern as the `.eslintignore` file. + */ + ignorePatterns?: string | string[]; + rules?: Rules; + settings?: Settings; + overrides?: Overrides; + [k: string]: unknown; +} +/** + * By default, ESLint supports only ECMAScript 5 syntax. You can override that setting to enable support for ECMAScript 6 as well as JSX by using configuration settings. + */ +export interface EcmaFeatures { + arrowFunctions?: boolean; + binaryLiterals?: boolean; + blockBindings?: boolean; + classes?: boolean; + defaultParams?: boolean; + destructuring?: boolean; + /** + * Enables support for the experimental object rest/spread properties (IMPORTANT: This is an experimental feature that may change significantly in the future. It's recommended that you do not write rules relying on this functionality unless you are willing to incur maintenance cost when it changes.) + */ + experimentalObjectRestSpread?: boolean; + forOf?: boolean; + generators?: boolean; + /** + * allow return statements in the global scope + */ + globalReturn?: boolean; + /** + * enable global strict mode (if ecmaVersion is 5 or greater) + */ + impliedStrict?: boolean; + /** + * enable JSX + */ + jsx?: boolean; + modules?: boolean; + objectLiteralComputedProperties?: boolean; + objectLiteralDuplicateProperties?: boolean; + objectLiteralShorthandMethods?: boolean; + objectLiteralShorthandProperties?: boolean; + octalLiterals?: boolean; + regexUFlag?: boolean; + regexYFlag?: boolean; + restParams?: boolean; + spread?: boolean; + superInFunctions?: boolean; + templateStrings?: boolean; + unicodeCodePointEscapes?: boolean; + [k: string]: unknown; +} +/** + * An environment defines global variables that are predefined. + */ +export interface Env { + /** + * defines require() and define() as global variables as per the amd spec + */ + amd?: boolean; + /** + * AppleScript global variables + */ + applescript?: boolean; + /** + * Atom test helper globals + */ + atomtest?: boolean; + /** + * browser global variables + */ + browser?: boolean; + /** + * CommonJS global variables and CommonJS scoping (use this for browser-only code that uses Browserify/WebPack) + */ + commonjs?: boolean; + /** + * Globals common to both Node and Browser + */ + "shared-node-browser"?: boolean; + /** + * Ember test helper globals + */ + embertest?: boolean; + /** + * enable all ECMAScript 6 features except for modules + */ + es6?: boolean; + /** + * GreaseMonkey globals + */ + greasemonkey?: boolean; + /** + * adds all of the Jasmine testing global variables for version 1.3 and 2.0 + */ + jasmine?: boolean; + /** + * Jest global variables + */ + jest?: boolean; + /** + * jQuery global variables + */ + jquery?: boolean; + /** + * Meteor global variables + */ + meteor?: boolean; + /** + * adds all of the Mocha test global variables + */ + mocha?: boolean; + /** + * MongoDB global variables + */ + mongo?: boolean; + /** + * Java 8 Nashorn global variables + */ + nashorn?: boolean; + /** + * Node.js global variables and Node.js scoping + */ + node?: boolean; + /** + * PhantomJS global variables + */ + phantomjs?: boolean; + /** + * Prototype.js global variables + */ + prototypejs?: boolean; + /** + * Protractor global variables + */ + protractor?: boolean; + /** + * QUnit global variables + */ + qunit?: boolean; + /** + * Service Worker global variables + */ + serviceworker?: boolean; + /** + * ShellJS global variables + */ + shelljs?: boolean; + /** + * WebExtensions globals + */ + webextensions?: boolean; + /** + * web workers global variables + */ + worker?: boolean; + [k: string]: unknown; +} +/** + * Set each global variable name equal to true to allow the variable to be overwritten or false to disallow overwriting. + */ +export interface Globals { + [k: string]: ("readonly" | "writable" | "off") | boolean; +} +/** + * The JavaScript language options to be supported + */ +export interface ParserOptions { + ecmaFeatures?: EcmaFeatures; + /** + * Set to 3, 5 (default), 6, 7, 8, 9, 10, 11, 12, 13, 14, or 15 to specify the version of ECMAScript syntax you want to use. You can also set it to 2015 (same as 6), 2016 (same as 7), 2017 (same as 8), 2018 (same as 9), 2019 (same as 10), 2020 (same as 11), 2021 (same as 12), 2022 (same as 13), 2023 (same as 14), or 2024 (same as 15) to use the year-based naming. You can also set "latest" to use the most recently supported version. + */ + ecmaVersion?: + | 3 + | 5 + | 6 + | 2015 + | 7 + | 2016 + | 8 + | 2017 + | 9 + | 2018 + | 10 + | 2019 + | 11 + | 2020 + | 12 + | 2021 + | 13 + | 2022 + | 14 + | 2023 + | 15 + | 2024 + | "latest"; + /** + * set to "script" (default), "commonjs", or "module" if your code is in ECMAScript modules + */ + sourceType?: "script" | "module" | "commonjs"; + [k: string]: unknown; +} +export interface PossibleErrors { + /** + * Require or disallow trailing commas + */ + "comma-dangle"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce "for" loop update clause moving the counter in the right direction + */ + "for-direction"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce return statements in getters + */ + "getter-return"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow await inside of loops + */ + "no-await-in-loop"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow comparing against -0 + */ + "no-compare-neg-zero"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow assignment operators in conditional expressions + */ + "no-cond-assign"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow the use of console + */ + "no-console"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow constant expressions in conditions + */ + "no-constant-condition"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow control characters in regular expressions + */ + "no-control-regex"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow the use of debugger + */ + "no-debugger"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow duplicate arguments in function definitions + */ + "no-dupe-args"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow duplicate keys in object literals + */ + "no-dupe-keys"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow duplicate case labels + */ + "no-duplicate-case"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow empty block statements + */ + "no-empty"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow empty character classes in regular expressions + */ + "no-empty-character-class"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow reassigning exceptions in catch clauses + */ + "no-ex-assign"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow unnecessary boolean casts + */ + "no-extra-boolean-cast"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow unnecessary parentheses + */ + "no-extra-parens"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow unnecessary semicolons + */ + "no-extra-semi"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow reassigning function declarations + */ + "no-func-assign"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow function or var declarations in nested blocks + */ + "no-inner-declarations"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow invalid regular expression strings in RegExp constructors + */ + "no-invalid-regexp"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow irregular whitespace outside of strings and comments + */ + "no-irregular-whitespace"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow negating the left operand in in expressions (deprecated) + */ + "no-negated-in-lhs"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow calling global object properties as functions + */ + "no-obj-calls"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow calling some Object.prototype methods directly on objects + */ + "no-prototype-builtins"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow multiple spaces in regular expressions + */ + "no-regex-spaces"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow sparse arrays + */ + "no-sparse-arrays"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow template literal placeholder syntax in regular strings + */ + "no-template-curly-in-string"?: + | number + | ("off" | "warn" | "error") + | unknown[]; + /** + * Disallow confusing multiline expressions + */ + "no-unexpected-multiline"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow unreachable code after return, throw, continue, and break statements + */ + "no-unreachable"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow control flow statements in finally blocks + */ + "no-unsafe-finally"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow negating the left operand of relational operators + */ + "no-unsafe-negation"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require calls to isNaN() when checking for NaN + */ + "use-isnan"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce valid JSDoc comments + */ + "valid-jsdoc"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce comparing typeof expressions against valid strings + */ + "valid-typeof"?: number | ("off" | "warn" | "error") | unknown[]; + [k: string]: unknown; +} +export interface BestPractices { + /** + * Enforce getter and setter pairs in objects + */ + "accessor-pairs"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce return statements in callbacks of array methods + */ + "array-callback-return"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce the use of variables within the scope they are defined + */ + "block-scoped-var"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce that class methods utilize this + */ + "class-methods-use-this"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce a maximum cyclomatic complexity allowed in a program + */ + complexity?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require return statements to either always or never specify values + */ + "consistent-return"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent brace style for all control statements + */ + curly?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require default cases in switch statements + */ + "default-case"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent newlines before and after dots + */ + "dot-location"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce dot notation whenever possible + */ + "dot-notation"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require the use of === and !== + */ + eqeqeq?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require for-in loops to include an if statement + */ + "guard-for-in"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow the use of alert, confirm, and prompt + */ + "no-alert"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow the use of arguments.caller or arguments.callee + */ + "no-caller"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow lexical declarations in case clauses + */ + "no-case-declarations"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow division operators explicitly at the beginning of regular expressions + */ + "no-div-regex"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow else blocks after return statements in if statements + */ + "no-else-return"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow empty functions + */ + "no-empty-function"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow empty destructuring patterns + */ + "no-empty-pattern"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow null comparisons without type-checking operators + */ + "no-eq-null"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow the use of eval() + */ + "no-eval"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow extending native types + */ + "no-extend-native"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow unnecessary calls to .bind() + */ + "no-extra-bind"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow unnecessary labels + */ + "no-extra-label"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow fallthrough of case statements + */ + "no-fallthrough"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow leading or trailing decimal points in numeric literals + */ + "no-floating-decimal"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow assignments to native objects or read-only global variables + */ + "no-global-assign"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow shorthand type conversions + */ + "no-implicit-coercion"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow var and named function declarations in the global scope + */ + "no-implicit-globals"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow the use of eval()-like methods + */ + "no-implied-eval"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow this keywords outside of classes or class-like objects + */ + "no-invalid-this"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow the use of the __iterator__ property + */ + "no-iterator"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow labeled statements + */ + "no-labels"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow unnecessary nested blocks + */ + "no-lone-blocks"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow function declarations and expressions inside loop statements + */ + "no-loop-func"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow magic numbers + */ + "no-magic-numbers"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow multiple spaces + */ + "no-multi-spaces"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow multiline strings + */ + "no-multi-str"?: number | ("off" | "warn" | "error") | unknown[]; + "no-native-reassign"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow new operators outside of assignments or comparisons + */ + "no-new"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow new operators with the Function object + */ + "no-new-func"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow new operators with the String, Number, and Boolean objects + */ + "no-new-wrappers"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow octal literals + */ + "no-octal"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow octal escape sequences in string literals + */ + "no-octal-escape"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow reassigning function parameters + */ + "no-param-reassign"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow the use of the __proto__ property + */ + "no-proto"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow var redeclaration + */ + "no-redeclare"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow certain properties on certain objects + */ + "no-restricted-properties"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow assignment operators in return statements + */ + "no-return-assign"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow unnecessary return await + */ + "no-return-await"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow javascript: urls + */ + "no-script-url"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow assignments where both sides are exactly the same + */ + "no-self-assign"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow comparisons where both sides are exactly the same + */ + "no-self-compare"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow comma operators + */ + "no-sequences"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow throwing literals as exceptions + */ + "no-throw-literal"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow unmodified loop conditions + */ + "no-unmodified-loop-condition"?: + | number + | ("off" | "warn" | "error") + | unknown[]; + /** + * Disallow unused expressions + */ + "no-unused-expressions"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow unused labels + */ + "no-unused-labels"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow unnecessary calls to .call() and .apply() + */ + "no-useless-call"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow unnecessary concatenation of literals or template literals + */ + "no-useless-concat"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow unnecessary escape characters + */ + "no-useless-escape"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow redundant return statements + */ + "no-useless-return"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow void operators + */ + "no-void"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow specified warning terms in comments + */ + "no-warning-comments"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow with statements + */ + "no-with"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require using Error objects as Promise rejection reasons + */ + "prefer-promise-reject-errors"?: + | number + | ("off" | "warn" | "error") + | unknown[]; + /** + * Enforce the consistent use of the radix argument when using parseInt() + */ + radix?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow async functions which have no await expression + */ + "require-await"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require var declarations be placed at the top of their containing scope + */ + "vars-on-top"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require parentheses around immediate function invocations + */ + "wrap-iife"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require or Disallow "Yoda" conditions + */ + yoda?: number | ("off" | "warn" | "error") | unknown[]; + [k: string]: unknown; +} +export interface StrictMode { + /** + * require or disallow strict mode directives + */ + strict?: number | ("off" | "warn" | "error") | unknown[]; + [k: string]: unknown; +} +export interface Variables { + /** + * Require or disallow initialization in var declarations + */ + "init-declarations"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow catch clause parameters from shadowing variables in the outer scope + */ + "no-catch-shadow"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow deleting variables + */ + "no-delete-var"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow labels that share a name with a variable + */ + "no-label-var"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow specified global variables + */ + "no-restricted-globals"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow var declarations from shadowing variables in the outer scope + */ + "no-shadow"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow identifiers from shadowing restricted names + */ + "no-shadow-restricted-names"?: + | number + | ("off" | "warn" | "error") + | unknown[]; + /** + * Disallow the use of undeclared variables unless mentioned in /*global * / comments + */ + "no-undef"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow the use of undefined as an identifier + */ + "no-undefined"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow initializing variables to undefined + */ + "no-undef-init"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow unused variables + */ + "no-unused-vars"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow the use of variables before they are defined + */ + "no-use-before-define"?: number | ("off" | "warn" | "error") | unknown[]; + [k: string]: unknown; +} +export interface NodeAndCommonJs { + /** + * Require return statements after callbacks + */ + "callback-return"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require require() calls to be placed at top-level module scope + */ + "global-require"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require error handling in callbacks + */ + "handle-callback-err"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow use of the Buffer() constructor + */ + "no-buffer-constructor"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow require calls to be mixed with regular var declarations + */ + "no-mixed-requires"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow new operators with calls to require + */ + "no-new-require"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow string concatenation with __dirname and __filename + */ + "no-path-concat"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow the use of process.env + */ + "no-process-env"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow the use of process.exit() + */ + "no-process-exit"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow specified modules when loaded by require + */ + "no-restricted-modules"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow synchronous methods + */ + "no-sync"?: number | ("off" | "warn" | "error") | unknown[]; + [k: string]: unknown; +} +export interface StylisticIssues { + /** + * Enforce line breaks after opening and before closing array brackets + */ + "array-bracket-newline"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent spacing inside array brackets + */ + "array-bracket-spacing"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce line breaks after each array element + */ + "array-element-newline"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent spacing inside single-line blocks + */ + "block-spacing"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent brace style for blocks + */ + "brace-style"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce camelcase naming convention + */ + camelcase?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce or disallow capitalization of the first letter of a comment + */ + "capitalized-comments"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require or disallow trailing commas + */ + "comma-dangle"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent spacing before and after commas + */ + "comma-spacing"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent comma style + */ + "comma-style"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent spacing inside computed property brackets + */ + "computed-property-spacing"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent naming when capturing the current execution context + */ + "consistent-this"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce at least one newline at the end of files + */ + "eol-last"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require or disallow spacing between function identifiers and their invocations + */ + "func-call-spacing"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require function names to match the name of the variable or property to which they are assigned + */ + "func-name-matching"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require or disallow named function expressions + */ + "func-names"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce the consistent use of either function declarations or expressions + */ + "func-style"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce line breaks between arguments of a function call + */ + "function-call-argument-newline"?: + | number + | ("off" | "warn" | "error") + | unknown[]; + /** + * Enforce consistent line breaks inside function parentheses + */ + "function-paren-newline"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow specified identifiers + */ + "id-blacklist"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce minimum and maximum identifier lengths + */ + "id-length"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require identifiers to match a specified regular expression + */ + "id-match"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce the location of arrow function bodies + */ + "implicit-arrow-linebreak"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent indentation + */ + indent?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent indentation (legacy, deprecated) + */ + "indent-legacy"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce the consistent use of either double or single quotes in JSX attributes + */ + "jsx-quotes"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent spacing between keys and values in object literal properties + */ + "key-spacing"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent spacing before and after keywords + */ + "keyword-spacing"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce position of line comments + */ + "line-comment-position"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require or disallow an empty line between class members + */ + "lines-between-class-members"?: + | number + | ("off" | "warn" | "error") + | unknown[]; + /** + * Enforce consistent linebreak style + */ + "linebreak-style"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require empty lines around comments + */ + "lines-around-comment"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require or disallow newlines around directives + */ + "lines-around-directive"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce a maximum depth that blocks can be nested + */ + "max-depth"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce a maximum line length + */ + "max-len"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce a maximum number of lines per file + */ + "max-lines"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce a maximum depth that callbacks can be nested + */ + "max-nested-callbacks"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce a maximum number of parameters in function definitions + */ + "max-params"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce a maximum number of statements allowed in function blocks + */ + "max-statements"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce a maximum number of statements allowed per line + */ + "max-statements-per-line"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce a particular style for multiline comments + */ + "multiline-comment-style"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce newlines between operands of ternary expressions + */ + "multiline-ternary"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require constructor function names to begin with a capital letter + */ + "new-cap"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require or disallow an empty line after var declarations + */ + "newline-after-var"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require an empty line before return statements + */ + "newline-before-return"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require a newline after each call in a method chain + */ + "newline-per-chained-call"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require parentheses when invoking a constructor with no arguments + */ + "new-parens"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow Array constructors + */ + "no-array-constructor"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow bitwise operators + */ + "no-bitwise"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow continue statements + */ + "no-continue"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow inline comments after code + */ + "no-inline-comments"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow if statements as the only statement in else blocks + */ + "no-lonely-if"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow mixed binary operators + */ + "no-mixed-operators"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow mixed spaces and tabs for indentation + */ + "no-mixed-spaces-and-tabs"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow use of chained assignment expressions + */ + "no-multi-assign"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow multiple empty lines + */ + "no-multiple-empty-lines"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow negated conditions + */ + "no-negated-condition"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow nested ternary expressions + */ + "no-nested-ternary"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow Object constructors + */ + "no-new-object"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow the unary operators ++ and -- + */ + "no-plusplus"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow specified syntax + */ + "no-restricted-syntax"?: number | ("off" | "warn" | "error") | unknown[]; + "no-spaced-func"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow tabs in file + */ + "no-tabs"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow ternary operators + */ + "no-ternary"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow trailing whitespace at the end of lines + */ + "no-trailing-spaces"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow dangling underscores in identifiers + */ + "no-underscore-dangle"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow ternary operators when simpler alternatives exist + */ + "no-unneeded-ternary"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow whitespace before properties + */ + "no-whitespace-before-property"?: + | number + | ("off" | "warn" | "error") + | unknown[]; + /** + * Enforce the location of single-line statements + */ + "nonblock-statement-body-position"?: + | number + | ("off" | "warn" | "error") + | unknown[]; + /** + * Enforce consistent line breaks inside braces + */ + "object-curly-newline"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent spacing inside braces + */ + "object-curly-spacing"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce placing object properties on separate lines + */ + "object-property-newline"?: number | ("off" | "warn" | "error") | unknown[]; + "object-shorthand"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce variables to be declared either together or separately in functions + */ + "one-var"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require or disallow newlines around var declarations + */ + "one-var-declaration-per-line"?: + | number + | ("off" | "warn" | "error") + | unknown[]; + /** + * Require or disallow assignment operator shorthand where possible + */ + "operator-assignment"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent linebreak style for operators + */ + "operator-linebreak"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require or disallow padding within blocks + */ + "padded-blocks"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require or disallow padding lines between statements + */ + "padding-line-between-statements"?: + | number + | ("off" | "warn" | "error") + | unknown[]; + /** + * Require quotes around object literal property names + */ + "quote-props"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce the consistent use of either backticks, double, or single quotes + */ + quotes?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require JSDoc comments + */ + "require-jsdoc"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require or disallow semicolons instead of ASI + */ + semi?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent spacing before and after semicolons + */ + "semi-spacing"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce location of semicolons + */ + "semi-style"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Requires object keys to be sorted + */ + "sort-keys"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require variables within the same declaration block to be sorted + */ + "sort-vars"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent spacing before blocks + */ + "space-before-blocks"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent spacing before function definition opening parenthesis + */ + "space-before-function-paren"?: + | number + | ("off" | "warn" | "error") + | unknown[]; + /** + * Enforce consistent spacing after the // or /* in a comment + */ + "spaced-comment"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require spacing around operators + */ + "space-infix-ops"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent spacing inside parentheses + */ + "space-in-parens"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent spacing before or after unary operators + */ + "space-unary-ops"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce spacing around colons of switch statements + */ + "switch-colon-spacing"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require or disallow spacing between template tags and their literals + */ + "template-tag-spacing"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require or disallow Unicode byte order mark (BOM) + */ + "unicode-bom"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require parenthesis around regex literals + */ + "wrap-regex"?: number | ("off" | "warn" | "error") | unknown[]; + [k: string]: unknown; +} +export interface EcmaScript6 { + /** + * Require braces around arrow function bodies + */ + "arrow-body-style"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require parentheses around arrow function arguments + */ + "arrow-parens"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent spacing before and after the arrow in arrow functions + */ + "arrow-spacing"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require super() calls in constructors + */ + "constructor-super"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce consistent spacing around * operators in generator functions + */ + "generator-star-spacing"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow reassigning class members + */ + "no-class-assign"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow arrow functions where they could be confused with comparisons + */ + "no-confusing-arrow"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow reassigning const variables + */ + "no-const-assign"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow duplicate class members + */ + "no-dupe-class-members"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow duplicate module imports + */ + "no-duplicate-imports"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow new operators with the Symbol object + */ + "no-new-symbol"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow specified modules when loaded by import + */ + "no-restricted-imports"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow this/super before calling super() in constructors + */ + "no-this-before-super"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow unnecessary computed property keys in object literals + */ + "no-useless-computed-key"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow unnecessary constructors + */ + "no-useless-constructor"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow renaming import, export, and destructured assignments to the same name + */ + "no-useless-rename"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require let or const instead of var + */ + "no-var"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require or disallow method and property shorthand syntax for object literals + */ + "object-shorthand"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require arrow functions as callbacks + */ + "prefer-arrow-callback"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require const declarations for variables that are never reassigned after declared + */ + "prefer-const"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require destructuring from arrays and/or objects + */ + "prefer-destructuring"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Disallow parseInt() in favor of binary, octal, and hexadecimal literals + */ + "prefer-numeric-literals"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require Reflect methods where applicable + */ + "prefer-reflect"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require rest parameters instead of arguments + */ + "prefer-rest-params"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require spread operators instead of .apply() + */ + "prefer-spread"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require template literals instead of string concatenation + */ + "prefer-template"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require generator functions to contain yield + */ + "require-yield"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce spacing between rest and spread operators and their expressions + */ + "rest-spread-spacing"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Enforce sorted import declarations within modules + */ + "sort-imports"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require symbol descriptions + */ + "symbol-description"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require or disallow spacing around embedded expressions of template strings + */ + "template-curly-spacing"?: number | ("off" | "warn" | "error") | unknown[]; + /** + * Require or disallow spacing around the * in yield* expressions + */ + "yield-star-spacing"?: number | ("off" | "warn" | "error") | unknown[]; + [k: string]: unknown; +} +export interface Legacy { + "max-depth"?: number | ("off" | "warn" | "error") | unknown[]; + "max-len"?: number | ("off" | "warn" | "error") | unknown[]; + "max-params"?: number | ("off" | "warn" | "error") | unknown[]; + "max-statements"?: number | ("off" | "warn" | "error") | unknown[]; + "no-bitwise"?: number | ("off" | "warn" | "error") | unknown[]; + "no-plusplus"?: number | ("off" | "warn" | "error") | unknown[]; + [k: string]: unknown; +} +export interface HttpsJsonSchemastoreOrgPartialEslintPluginsJson { + /** + * Classes decorated with @Component must have suffix "Component" (or custom) in their name. See more at https://angular.dev/style-guide#style-02-03 + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/component-class-suffix.md + */ + "@angular-eslint/component-class-suffix"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + suffixes?: string[]; + [k: string]: unknown; + }, + ]; + /** + * Enforces a maximum number of lines in inline template, styles and animations. See more at https://angular.dev/style-guide#style-05-04 + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/component-max-inline-declarations.md + */ + "@angular-eslint/component-max-inline-declarations"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + template?: number; + styles?: number; + animations?: number; + [k: string]: unknown; + }, + ]; + /** + * Component selectors should follow given naming rules. See more at https://angular.dev/style-guide#style-02-07, https://angular.dev/style-guide#style-05-02 + * and https://angular.dev/style-guide#style-05-03. + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/component-selector.md + */ + "@angular-eslint/component-selector"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + type?: string | ("element" | "attribute")[]; + prefix?: string | unknown[]; + style?: "camelCase" | "kebab-case"; + [k: string]: unknown; + }, + ]; + /** + * Ensures consistent usage of `styles`/`styleUrls`/`styleUrl` within Component metadata + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/consistent-component-styles.md + */ + "@angular-eslint/consistent-component-styles"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + [k: string]: unknown; + }, + ]; + /** + * Ensures that classes use contextual decorators in its body + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/contextual-decorator.md + */ + "@angular-eslint/contextual-decorator"?: { + [k: string]: unknown; + }; + /** + * Ensures that lifecycle methods are used in a correct context + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/contextual-lifecycle.md + */ + "@angular-eslint/contextual-lifecycle"?: { + [k: string]: unknown; + }; + /** + * Classes decorated with @Directive must have suffix "Directive" (or custom) in their name. See more at https://angular.dev/style-guide#style-02-03 + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/directive-class-suffix.md + */ + "@angular-eslint/directive-class-suffix"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + suffixes?: string[]; + [k: string]: unknown; + }, + ]; + /** + * Directive selectors should follow given naming rules. See more at https://angular.dev/style-guide#style-02-06 and https://angular.dev/style-guide#style-02-08. + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/directive-selector.md + */ + "@angular-eslint/directive-selector"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + type?: string | ("element" | "attribute")[]; + prefix?: string | unknown[]; + style?: "camelCase" | "kebab-case"; + [k: string]: unknown; + }, + ]; + /** + * Angular Lifecycle methods should not be async. Angular does not wait for async lifecycle but the code incorrectly suggests it does. + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-async-lifecycle-method.md + */ + "@angular-eslint/no-async-lifecycle-method"?: { + [k: string]: unknown; + }; + /** + * The @Attribute decorator is used to obtain a single value for an attribute. This is a much less common use-case than getting a stream of values (using @Input), so often the @Attribute decorator is mistakenly used when @Input was what was intended. This rule disallows usage of @Attribute decorator altogether in order to prevent these mistakes. + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-attribute-decorator.md + */ + "@angular-eslint/no-attribute-decorator"?: { + [k: string]: unknown; + }; + /** + * Ensures that directives not implement conflicting lifecycle interfaces. + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-conflicting-lifecycle.md + */ + "@angular-eslint/no-conflicting-lifecycle"?: { + [k: string]: unknown; + }; + /** + * Ensures that metadata arrays do not contain duplicate entries. + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-duplicates-in-metadata-arrays.md + */ + "@angular-eslint/no-duplicates-in-metadata-arrays"?: { + [k: string]: unknown; + }; + /** + * Disallows declaring empty lifecycle methods + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-empty-lifecycle-method.md + */ + "@angular-eslint/no-empty-lifecycle-method"?: { + [k: string]: unknown; + }; + /** + * Disallows usage of `forwardRef` references for DI + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-forward-ref.md + */ + "@angular-eslint/no-forward-ref"?: { + [k: string]: unknown; + }; + /** + * Disallows usage of the `host` metadata property. NOTE: This used to be recommended by the Angular Team, but now they recommend the exact opposite: https://github.com/angular/angular/issues/54284 + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-host-metadata-property.md + */ + "@angular-eslint/no-host-metadata-property"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + allowStatic?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Ensures that input bindings, including aliases, are not named or prefixed by the configured disallowed prefixes + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-input-prefix.md + */ + "@angular-eslint/no-input-prefix"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + prefixes?: string[]; + [k: string]: unknown; + }, + ]; + /** + * Ensures that input bindings are not aliased + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-input-rename.md + */ + "@angular-eslint/no-input-rename"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + /** + * A list with allowed input names + */ + allowedNames?: string[]; + [k: string]: unknown; + }, + ]; + /** + * Disallows usage of the `inputs` metadata property. See more at https://angular.dev/style-guide#style-05-12 + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-inputs-metadata-property.md + */ + "@angular-eslint/no-inputs-metadata-property"?: { + [k: string]: unknown; + }; + /** + * Disallows explicit calls to lifecycle methods + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-lifecycle-call.md + */ + "@angular-eslint/no-lifecycle-call"?: { + [k: string]: unknown; + }; + /** + * Ensures that output bindings, including aliases, are not named as standard DOM events + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-output-native.md + */ + "@angular-eslint/no-output-native"?: { + [k: string]: unknown; + }; + /** + * Ensures that output bindings, including aliases, are not named "on", nor prefixed with it. See more at https://angular.dev/style-guide#style-05-16 + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-output-on-prefix.md + */ + "@angular-eslint/no-output-on-prefix"?: { + [k: string]: unknown; + }; + /** + * Ensures that output bindings are not aliased + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-output-rename.md + */ + "@angular-eslint/no-output-rename"?: { + [k: string]: unknown; + }; + /** + * Disallows usage of the `outputs` metadata property. See more at https://angular.dev/style-guide#style-05-12 + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-outputs-metadata-property.md + */ + "@angular-eslint/no-outputs-metadata-property"?: { + [k: string]: unknown; + }; + /** + * Disallows the declaration of impure pipes + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-pipe-impure.md + */ + "@angular-eslint/no-pipe-impure"?: { + [k: string]: unknown; + }; + /** + * Disallows usage of the `queries` metadata property. See more at https://angular.dev/style-guide#style-05-12. + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-queries-metadata-property.md + */ + "@angular-eslint/no-queries-metadata-property"?: { + [k: string]: unknown; + }; + /** + * Enforce consistent prefix for pipes. + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/pipe-prefix.md + */ + "@angular-eslint/pipe-prefix"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + prefixes?: string[]; + [k: string]: unknown; + }, + ]; + /** + * Ensures component's `changeDetection` is set to `ChangeDetectionStrategy.OnPush` + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-on-push-component-change-detection.md + */ + "@angular-eslint/prefer-on-push-component-change-detection"?: { + [k: string]: unknown; + }; + /** + * Ensures component, directive and pipe `standalone` property is set to `true` in the component decorator + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-standalone.md + */ + "@angular-eslint/prefer-standalone"?: { + [k: string]: unknown; + }; + /** + * Ensures component `standalone` property is set to `true` in the component decorator + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-standalone-component.md + */ + "@angular-eslint/prefer-standalone-component"?: { + [k: string]: unknown; + }; + /** + * Prefer to declare `@Output` as `readonly` since they are not supposed to be reassigned + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-output-readonly.md + */ + "@angular-eslint/prefer-output-readonly"?: { + [k: string]: unknown; + }; + /** + * The ./ and ../ prefix is standard syntax for relative URLs; don't depend on Angular's current ability to do without that prefix. See more at https://angular.dev/style-guide#style-05-04 + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/relative-url-prefix.md + */ + "@angular-eslint/relative-url-prefix"?: { + [k: string]: unknown; + }; + /** + * Ensures that $localize tagged messages contain helpful metadata to aid with translations. + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/require-localize-metadata.md + */ + "@angular-eslint/require-localize-metadata"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + requireDescription?: boolean; + requireMeaning?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Ensures that lifecycle methods are declared in order of execution + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/sort-lifecycle-methods.md + */ + "@angular-eslint/sort-lifecycle-methods"?: { + [k: string]: unknown; + }; + /** + * Ensures ASC alphabetical order for `NgModule` metadata arrays for easy visual scanning + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/sort-ngmodule-metadata-arrays.md + */ + "@angular-eslint/sort-ngmodule-metadata-arrays"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + /** + * A string with a BCP 47 language tag. + */ + locale?: string; + [k: string]: unknown; + }, + ]; + /** + * Component selector must be declared + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/use-component-selector.md + */ + "@angular-eslint/use-component-selector"?: { + [k: string]: unknown; + }; + /** + * Disallows using `ViewEncapsulation.None` + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/use-component-view-encapsulation.md + */ + "@angular-eslint/use-component-view-encapsulation"?: { + [k: string]: unknown; + }; + /** + * Using the `providedIn` property makes `Injectables` tree-shakable + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/use-injectable-provided-in.md + */ + "@angular-eslint/use-injectable-provided-in"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + ignoreClassNamePattern?: string; + [k: string]: unknown; + }, + ]; + /** + * Ensures that classes implement lifecycle interfaces corresponding to the declared lifecycle methods. See more at https://angular.dev/style-guide#style-09-01 + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/use-lifecycle-interface.md + */ + "@angular-eslint/use-lifecycle-interface"?: { + [k: string]: unknown; + }; + /** + * Ensures that `Pipes` implement `PipeTransform` interface + * https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/use-pipe-transform-interface.md + */ + "@angular-eslint/use-pipe-transform-interface"?: { + [k: string]: unknown; + }; + /** + * Ensure imports point to a file/module that can be resolved. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-unresolved.md + */ + "eslint-plugin-import/no-unresolved"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + commonjs?: boolean; + amd?: boolean; + esmodule?: boolean; + /** + * @minItems 1 + */ + ignore?: [string, ...string[]]; + caseSensitive?: boolean; + caseSensitiveStrict?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Ensure named imports correspond to a named export in the remote file. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/named.md + */ + "eslint-plugin-import/named"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + commonjs?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Ensure a default export is present, given a default import. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/default.md + */ + "eslint-plugin-import/default"?: { + [k: string]: unknown; + }; + /** + * Ensure imported namespaces contain dereferenced properties as they are dereferenced. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/namespace.md + */ + "eslint-plugin-import/namespace"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + /** + * If `false`, will report computed (and thus, un-lintable) references to namespace members. + */ + allowComputed?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Forbid namespace (a.k.a. "wildcard" `*`) imports. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-namespace.md + */ + "eslint-plugin-import/no-namespace"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + ignore?: string[]; + [k: string]: unknown; + }, + ]; + /** + * Forbid any invalid exports, i.e. re-export of the same name. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/export.md + */ + "eslint-plugin-import/export"?: { + [k: string]: unknown; + }; + /** + * Forbid the use of mutable exports with `var` or `let`. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-mutable-exports.md + */ + "eslint-plugin-import/no-mutable-exports"?: { + [k: string]: unknown; + }; + /** + * Ensure consistent use of file extension within the import path. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/extensions.md + */ + "eslint-plugin-import/extensions"?: { + [k: string]: unknown; + }; + /** + * Enforce which files can be imported in a given folder. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-restricted-paths.md + */ + "eslint-plugin-import/no-restricted-paths"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + /** + * @minItems 1 + */ + zones?: [ + { + target?: string | [string, ...string[]]; + from?: string | [string, ...string[]]; + except?: string[]; + message?: string; + }, + ...{ + target?: string | [string, ...string[]]; + from?: string | [string, ...string[]]; + except?: string[]; + message?: string; + }[], + ]; + basePath?: string; + [k: string]: unknown; + }, + ]; + /** + * Forbid importing the submodules of other modules. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-internal-modules.md + */ + "eslint-plugin-import/no-internal-modules"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + [k: string]: unknown; + }, + ]; + /** + * Prefer named exports to be grouped together in a single export declaration + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/group-exports.md + */ + "eslint-plugin-import/group-exports"?: { + [k: string]: unknown; + }; + /** + * Forbid importing packages through relative paths. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-relative-packages.md + */ + "eslint-plugin-import/no-relative-packages"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + commonjs?: boolean; + amd?: boolean; + esmodule?: boolean; + /** + * @minItems 1 + */ + ignore?: [string, ...string[]]; + [k: string]: unknown; + }, + ]; + /** + * Forbid importing modules from parent directories. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-relative-parent-imports.md + */ + "eslint-plugin-import/no-relative-parent-imports"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + commonjs?: boolean; + amd?: boolean; + esmodule?: boolean; + /** + * @minItems 1 + */ + ignore?: [string, ...string[]]; + [k: string]: unknown; + }, + ]; + /** + * Enforce or ban the use of inline type-only markers for named imports. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/consistent-type-specifier-style.md + */ + "eslint-plugin-import/consistent-type-specifier-style"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + [k: string]: unknown; + }, + ]; + /** + * Forbid a module from importing itself. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-self-import.md + */ + "eslint-plugin-import/no-self-import"?: { + [k: string]: unknown; + }; + /** + * Forbid a module from importing a module with a dependency path back to itself. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-cycle.md + */ + "eslint-plugin-import/no-cycle"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + commonjs?: boolean; + amd?: boolean; + esmodule?: boolean; + /** + * @minItems 1 + */ + ignore?: [string, ...string[]]; + maxDepth?: number | "∞"; + /** + * ignore external modules + */ + ignoreExternal?: boolean; + /** + * Allow cyclic dependency if there is at least one dynamic import in the chain + */ + allowUnsafeDynamicCyclicDependency?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Forbid named default exports. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-named-default.md + */ + "eslint-plugin-import/no-named-default"?: { + [k: string]: unknown; + }; + /** + * Forbid use of exported name as identifier of default export. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-named-as-default.md + */ + "eslint-plugin-import/no-named-as-default"?: { + [k: string]: unknown; + }; + /** + * Forbid use of exported name as property of default export. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-named-as-default-member.md + */ + "eslint-plugin-import/no-named-as-default-member"?: { + [k: string]: unknown; + }; + /** + * Forbid anonymous values as default exports. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-anonymous-default-export.md + */ + "eslint-plugin-import/no-anonymous-default-export"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + /** + * If `false`, will report default export of an array + */ + allowArray?: boolean; + /** + * If `false`, will report default export of an arrow function + */ + allowArrowFunction?: boolean; + /** + * If `false`, will report default export of a function call + */ + allowCallExpression?: boolean; + /** + * If `false`, will report default export of an anonymous class + */ + allowAnonymousClass?: boolean; + /** + * If `false`, will report default export of an anonymous function + */ + allowAnonymousFunction?: boolean; + /** + * If `false`, will report default export of a literal + */ + allowLiteral?: boolean; + /** + * If `false`, will report default export of an object expression + */ + allowObject?: boolean; + /** + * If `false`, will report default export of a class instantiation + */ + allowNew?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Forbid modules without exports, or exports without matching import in another module. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-unused-modules.md + */ + "eslint-plugin-import/no-unused-modules"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + /** + * files/paths to be analyzed (only for unused exports) + */ + src?: string[]; + /** + * files/paths for which unused exports will not be reported (e.g module entry points) + */ + ignoreExports?: string[]; + /** + * report modules without any exports + */ + missingExports?: boolean; + /** + * report exports without any usage + */ + unusedExports?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Forbid CommonJS `require` calls and `module.exports` or `exports.*`. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-commonjs.md + */ + "eslint-plugin-import/no-commonjs"?: { + [k: string]: unknown; + }; + /** + * Forbid AMD `require` and `define` calls. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-amd.md + */ + "eslint-plugin-import/no-amd"?: { + [k: string]: unknown; + }; + /** + * Forbid repeated import of the same module in multiple places. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-duplicates.md + */ + "eslint-plugin-import/no-duplicates"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + considerQueryString?: boolean; + "prefer-inline"?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Ensure all imports appear before other statements. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/first.md + */ + "eslint-plugin-import/first"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + [k: string]: unknown; + }, + ]; + /** + * Enforce the maximum number of dependencies a module can have. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/max-dependencies.md + */ + "eslint-plugin-import/max-dependencies"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + max?: number; + ignoreTypeImports?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Forbid the use of extraneous packages. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-extraneous-dependencies.md + */ + "eslint-plugin-import/no-extraneous-dependencies"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + devDependencies?: boolean | unknown[]; + optionalDependencies?: boolean | unknown[]; + peerDependencies?: boolean | unknown[]; + bundledDependencies?: boolean | unknown[]; + packageDir?: string | unknown[]; + includeInternal?: boolean; + includeTypes?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Forbid import of modules using absolute paths. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-absolute-path.md + */ + "eslint-plugin-import/no-absolute-path"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + commonjs?: boolean; + amd?: boolean; + esmodule?: boolean; + /** + * @minItems 1 + */ + ignore?: [string, ...string[]]; + [k: string]: unknown; + }, + ]; + /** + * Forbid Node.js builtin modules. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-nodejs-modules.md + */ + "eslint-plugin-import/no-nodejs-modules"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + allow?: string[]; + [k: string]: unknown; + }, + ]; + /** + * Forbid webpack loader syntax in imports. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-webpack-loader-syntax.md + */ + "eslint-plugin-import/no-webpack-loader-syntax"?: { + [k: string]: unknown; + }; + /** + * Enforce a convention in module import order. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/order.md + */ + "eslint-plugin-import/order"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + groups?: unknown[]; + pathGroupsExcludedImportTypes?: unknown[]; + distinctGroup?: boolean; + pathGroups?: { + pattern: string; + patternOptions?: { + [k: string]: unknown; + }; + group: + | "builtin" + | "external" + | "internal" + | "unknown" + | "parent" + | "sibling" + | "index" + | "object" + | "type"; + position?: "after" | "before"; + }[]; + "newlines-between"?: + | "ignore" + | "always" + | "always-and-inside-groups" + | "never"; + alphabetize?: { + caseInsensitive?: boolean; + order?: "ignore" | "asc" | "desc"; + orderImportKind?: "ignore" | "asc" | "desc"; + }; + warnOnUnassignedImports?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Enforce a newline after import statements. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/newline-after-import.md + */ + "eslint-plugin-import/newline-after-import"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + count?: number; + exactCount?: boolean; + considerComments?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Prefer a default export if module exports a single name or multiple names. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/prefer-default-export.md + */ + "eslint-plugin-import/prefer-default-export"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + target?: "single" | "any"; + [k: string]: unknown; + }, + ]; + /** + * Forbid default exports. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-default-export.md + */ + "eslint-plugin-import/no-default-export"?: { + [k: string]: unknown; + }; + /** + * Forbid named exports. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-named-export.md + */ + "eslint-plugin-import/no-named-export"?: { + [k: string]: unknown; + }; + /** + * Forbid `require()` calls with expressions. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-dynamic-require.md + */ + "eslint-plugin-import/no-dynamic-require"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + esmodule?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Forbid potentially ambiguous parse goal (`script` vs. `module`). + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/unambiguous.md + */ + "eslint-plugin-import/unambiguous"?: { + [k: string]: unknown; + }; + /** + * Forbid unassigned imports + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-unassigned-import.md + */ + "eslint-plugin-import/no-unassigned-import"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + devDependencies?: boolean | unknown[]; + optionalDependencies?: boolean | unknown[]; + peerDependencies?: boolean | unknown[]; + allow?: string[]; + [k: string]: unknown; + }, + ]; + /** + * Forbid unnecessary path segments in import and require statements. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-useless-path-segments.md + */ + "eslint-plugin-import/no-useless-path-segments"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + commonjs?: boolean; + noUselessIndex?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Enforce a leading comment with the webpackChunkName for dynamic imports. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/dynamic-import-chunkname.md + */ + "eslint-plugin-import/dynamic-import-chunkname"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + importFunctions?: string[]; + webpackChunknameFormat?: string; + [k: string]: unknown; + }, + ]; + /** + * Forbid import statements with CommonJS module.exports. + * + */ + "eslint-plugin-import/no-import-module-exports"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + exceptions?: unknown[]; + [k: string]: unknown; + }, + ]; + /** + * Forbid empty named import blocks. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-empty-named-blocks.md + */ + "eslint-plugin-import/no-empty-named-blocks"?: { + [k: string]: unknown; + }; + /** + * Ensure all exports appear after other statements. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/exports-last.md + */ + "eslint-plugin-import/exports-last"?: { + [k: string]: unknown; + }; + /** + * Forbid imported names marked with `@deprecated` documentation tag. + * https://github.com/import-js/eslint-plugin-import/blob/v2.29.1/docs/rules/no-deprecated.md + */ + "eslint-plugin-import/no-deprecated"?: { + [k: string]: unknown; + }; + /** + * Replaced by `import/first`. + * https://github.com/import-js/eslint-plugin-import/blob/7b25c1cb95ee18acc1531002fd343e1e6031f9ed/docs/rules/imports-first.md + */ + "eslint-plugin-import/imports-first"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + [k: string]: unknown; + }, + ]; + /** + * Improve regexes by making them shorter, consistent, and safer. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/better-regex.md + */ + "eslint-plugin-unicorn/better-regex"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + sortCharacterClasses?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Enforce a specific parameter name in catch clauses. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/catch-error-name.md + */ + "eslint-plugin-unicorn/catch-error-name"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + name?: string; + ignore?: unknown[]; + [k: string]: unknown; + }, + ]; + /** + * Use destructured variables over properties. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/consistent-destructuring.md + */ + "eslint-plugin-unicorn/consistent-destructuring"?: { + [k: string]: unknown; + }; + /** + * Prefer consistent types when spreading a ternary in an array literal. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/consistent-empty-array-spread.md + */ + "eslint-plugin-unicorn/consistent-empty-array-spread"?: { + [k: string]: unknown; + }; + /** + * Move function definitions to the highest possible scope. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/consistent-function-scoping.md + */ + "eslint-plugin-unicorn/consistent-function-scoping"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + checkArrowFunctions?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Enforce correct `Error` subclassing. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/custom-error-definition.md + */ + "eslint-plugin-unicorn/custom-error-definition"?: { + [k: string]: unknown; + }; + /** + * Enforce no spaces between braces. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/empty-brace-spaces.md + */ + "eslint-plugin-unicorn/empty-brace-spaces"?: { + [k: string]: unknown; + }; + /** + * Enforce passing a `message` value when creating a built-in error. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/error-message.md + */ + "eslint-plugin-unicorn/error-message"?: { + [k: string]: unknown; + }; + /** + * Require escape sequences to use uppercase values. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/escape-case.md + */ + "eslint-plugin-unicorn/escape-case"?: { + [k: string]: unknown; + }; + /** + * Add expiration conditions to TODO comments. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/expiring-todo-comments.md + */ + "eslint-plugin-unicorn/expiring-todo-comments"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + terms?: string[]; + ignore?: unknown[]; + ignoreDatesOnPullRequests?: boolean; + allowWarningComments?: boolean; + date?: string; + [k: string]: unknown; + }, + ]; + /** + * Enforce explicitly comparing the `length` or `size` property of a value. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/explicit-length-check.md + */ + "eslint-plugin-unicorn/explicit-length-check"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + "non-zero"?: "greater-than" | "not-equal"; + [k: string]: unknown; + }, + ]; + /** + * Enforce a case style for filenames. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/filename-case.md + */ + "eslint-plugin-unicorn/filename-case"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + [k: string]: unknown; + }, + ]; + /** + * Enforce specific import styles per module. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/import-style.md + */ + "eslint-plugin-unicorn/import-style"?: { + [k: string]: unknown; + }; + /** + * Enforce the use of `new` for all builtins, except `String`, `Number`, `Boolean`, `Symbol` and `BigInt`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/new-for-builtins.md + */ + "eslint-plugin-unicorn/new-for-builtins"?: { + [k: string]: unknown; + }; + /** + * Enforce specifying rules to disable in `eslint-disable` comments. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-abusive-eslint-disable.md + */ + "eslint-plugin-unicorn/no-abusive-eslint-disable"?: { + [k: string]: unknown; + }; + /** + * Disallow anonymous functions and classes as the default export. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-anonymous-default-export.md + */ + "eslint-plugin-unicorn/no-anonymous-default-export"?: { + [k: string]: unknown; + }; + /** + * Prevent passing a function reference directly to iterator methods. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-array-callback-reference.md + */ + "eslint-plugin-unicorn/no-array-callback-reference"?: { + [k: string]: unknown; + }; + /** + * Prefer `for…of` over the `forEach` method. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-array-for-each.md + */ + "eslint-plugin-unicorn/no-array-for-each"?: { + [k: string]: unknown; + }; + /** + * Disallow using the `this` argument in array methods. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-array-method-this-argument.md + */ + "eslint-plugin-unicorn/no-array-method-this-argument"?: { + [k: string]: unknown; + }; + /** + * Enforce combining multiple `Array#push()` into one call. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-array-push-push.md + */ + "eslint-plugin-unicorn/no-array-push-push"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + ignore?: unknown[]; + [k: string]: unknown; + }, + ]; + /** + * Disallow `Array#reduce()` and `Array#reduceRight()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-array-reduce.md + */ + "eslint-plugin-unicorn/no-array-reduce"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + allowSimpleOperations?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Disallow member access from await expression. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-await-expression-member.md + */ + "eslint-plugin-unicorn/no-await-expression-member"?: { + [k: string]: unknown; + }; + /** + * Disallow using `await` in `Promise` method parameters. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-await-in-promise-methods.md + */ + "eslint-plugin-unicorn/no-await-in-promise-methods"?: { + [k: string]: unknown; + }; + /** + * Do not use leading/trailing space between `console.log` parameters. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-console-spaces.md + */ + "eslint-plugin-unicorn/no-console-spaces"?: { + [k: string]: unknown; + }; + /** + * Do not use `document.cookie` directly. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-document-cookie.md + */ + "eslint-plugin-unicorn/no-document-cookie"?: { + [k: string]: unknown; + }; + /** + * Disallow empty files. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-empty-file.md + */ + "eslint-plugin-unicorn/no-empty-file"?: { + [k: string]: unknown; + }; + /** + * Do not use a `for` loop that can be replaced with a `for-of` loop. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-for-loop.md + */ + "eslint-plugin-unicorn/no-for-loop"?: { + [k: string]: unknown; + }; + /** + * Enforce the use of Unicode escapes instead of hexadecimal escapes. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-hex-escape.md + */ + "eslint-plugin-unicorn/no-hex-escape"?: { + [k: string]: unknown; + }; + /** + * Require `Array.isArray()` instead of `instanceof Array`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-instanceof-array.md + */ + "eslint-plugin-unicorn/no-instanceof-array"?: { + [k: string]: unknown; + }; + /** + * Disallow invalid options in `fetch()` and `new Request()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-invalid-fetch-options.md + */ + "eslint-plugin-unicorn/no-invalid-fetch-options"?: { + [k: string]: unknown; + }; + /** + * Prevent calling `EventTarget#removeEventListener()` with the result of an expression. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-invalid-remove-event-listener.md + */ + "eslint-plugin-unicorn/no-invalid-remove-event-listener"?: { + [k: string]: unknown; + }; + /** + * Disallow identifiers starting with `new` or `class`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-keyword-prefix.md + */ + "eslint-plugin-unicorn/no-keyword-prefix"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + /** + * @minItems 1 + * @maxItems 1 + */ + disallowedPrefixes?: [string]; + checkProperties?: boolean; + onlyCamelCase?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Disallow `if` statements as the only statement in `if` blocks without `else`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-lonely-if.md + */ + "eslint-plugin-unicorn/no-lonely-if"?: { + [k: string]: unknown; + }; + /** + * Disallow a magic number as the `depth` argument in `Array#flat(…).` + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-magic-array-flat-depth.md + */ + "eslint-plugin-unicorn/no-magic-array-flat-depth"?: { + [k: string]: unknown; + }; + /** + * Disallow negated conditions. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-negated-condition.md + */ + "eslint-plugin-unicorn/no-negated-condition"?: { + [k: string]: unknown; + }; + /** + * Disallow negated expression in equality check. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-negation-in-equality-check.md + */ + "eslint-plugin-unicorn/no-negation-in-equality-check"?: { + [k: string]: unknown; + }; + /** + * Disallow nested ternary expressions. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-nested-ternary.md + */ + "eslint-plugin-unicorn/no-nested-ternary"?: { + [k: string]: unknown; + }; + /** + * Disallow `new Array()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-new-array.md + */ + "eslint-plugin-unicorn/no-new-array"?: { + [k: string]: unknown; + }; + /** + * Enforce the use of `Buffer.from()` and `Buffer.alloc()` instead of the deprecated `new Buffer()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-new-buffer.md + */ + "eslint-plugin-unicorn/no-new-buffer"?: { + [k: string]: unknown; + }; + /** + * Disallow the use of the `null` literal. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-null.md + */ + "eslint-plugin-unicorn/no-null"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + checkStrictEquality?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Disallow the use of objects as default parameters. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-object-as-default-parameter.md + */ + "eslint-plugin-unicorn/no-object-as-default-parameter"?: { + [k: string]: unknown; + }; + /** + * Disallow `process.exit()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-process-exit.md + */ + "eslint-plugin-unicorn/no-process-exit"?: { + [k: string]: unknown; + }; + /** + * Disallow passing single-element arrays to `Promise` methods. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-single-promise-in-promise-methods.md + */ + "eslint-plugin-unicorn/no-single-promise-in-promise-methods"?: { + [k: string]: unknown; + }; + /** + * Disallow classes that only have static members. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-static-only-class.md + */ + "eslint-plugin-unicorn/no-static-only-class"?: { + [k: string]: unknown; + }; + /** + * Disallow `then` property. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-thenable.md + */ + "eslint-plugin-unicorn/no-thenable"?: { + [k: string]: unknown; + }; + /** + * Disallow assigning `this` to a variable. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-this-assignment.md + */ + "eslint-plugin-unicorn/no-this-assignment"?: { + [k: string]: unknown; + }; + /** + * Disallow comparing `undefined` using `typeof`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-typeof-undefined.md + */ + "eslint-plugin-unicorn/no-typeof-undefined"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + checkGlobalVariables?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Disallow awaiting non-promise values. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-unnecessary-await.md + */ + "eslint-plugin-unicorn/no-unnecessary-await"?: { + [k: string]: unknown; + }; + /** + * Enforce the use of built-in methods instead of unnecessary polyfills. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-unnecessary-polyfills.md + */ + "eslint-plugin-unicorn/no-unnecessary-polyfills"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + targets?: + | string + | unknown[] + | { + [k: string]: unknown; + }; + [k: string]: unknown; + }, + ]; + /** + * Disallow unreadable array destructuring. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-unreadable-array-destructuring.md + */ + "eslint-plugin-unicorn/no-unreadable-array-destructuring"?: { + [k: string]: unknown; + }; + /** + * Disallow unreadable IIFEs. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-unreadable-iife.md + */ + "eslint-plugin-unicorn/no-unreadable-iife"?: { + [k: string]: unknown; + }; + /** + * Disallow unused object properties. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-unused-properties.md + */ + "eslint-plugin-unicorn/no-unused-properties"?: { + [k: string]: unknown; + }; + /** + * Disallow useless fallback when spreading in object literals. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-useless-fallback-in-spread.md + */ + "eslint-plugin-unicorn/no-useless-fallback-in-spread"?: { + [k: string]: unknown; + }; + /** + * Disallow useless array length check. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-useless-length-check.md + */ + "eslint-plugin-unicorn/no-useless-length-check"?: { + [k: string]: unknown; + }; + /** + * Disallow returning/yielding `Promise.resolve/reject()` in async functions or promise callbacks + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-useless-promise-resolve-reject.md + */ + "eslint-plugin-unicorn/no-useless-promise-resolve-reject"?: { + [k: string]: unknown; + }; + /** + * Disallow unnecessary spread. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-useless-spread.md + */ + "eslint-plugin-unicorn/no-useless-spread"?: { + [k: string]: unknown; + }; + /** + * Disallow useless case in switch statements. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-useless-switch-case.md + */ + "eslint-plugin-unicorn/no-useless-switch-case"?: { + [k: string]: unknown; + }; + /** + * Disallow useless `undefined`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-useless-undefined.md + */ + "eslint-plugin-unicorn/no-useless-undefined"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + checkArguments?: boolean; + checkArrowFunctionBody?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Disallow number literals with zero fractions or dangling dots. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/no-zero-fractions.md + */ + "eslint-plugin-unicorn/no-zero-fractions"?: { + [k: string]: unknown; + }; + /** + * Enforce proper case for numeric literals. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/number-literal-case.md + */ + "eslint-plugin-unicorn/number-literal-case"?: { + [k: string]: unknown; + }; + /** + * Enforce the style of numeric separators by correctly grouping digits. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/numeric-separators-style.md + */ + "eslint-plugin-unicorn/numeric-separators-style"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + binary?: { + onlyIfContainsSeparator?: boolean; + minimumDigits?: number; + groupLength?: number; + }; + octal?: { + onlyIfContainsSeparator?: boolean; + minimumDigits?: number; + groupLength?: number; + }; + hexadecimal?: { + onlyIfContainsSeparator?: boolean; + minimumDigits?: number; + groupLength?: number; + }; + number?: { + onlyIfContainsSeparator?: boolean; + minimumDigits?: number; + groupLength?: number; + }; + onlyIfContainsSeparator?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Prefer `.addEventListener()` and `.removeEventListener()` over `on`-functions. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-add-event-listener.md + */ + "eslint-plugin-unicorn/prefer-add-event-listener"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + excludedPackages?: string[]; + [k: string]: unknown; + }, + ]; + /** + * Prefer `.find(…)` and `.findLast(…)` over the first or last element from `.filter(…)`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-array-find.md + */ + "eslint-plugin-unicorn/prefer-array-find"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + checkFromLast?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Prefer `.flatMap(…)` over `.map(…).flat()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-array-flat-map.md + */ + "eslint-plugin-unicorn/prefer-array-flat-map"?: { + [k: string]: unknown; + }; + /** + * Prefer `Array#flat()` over legacy techniques to flatten arrays. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-array-flat.md + */ + "eslint-plugin-unicorn/prefer-array-flat"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + functions?: unknown[]; + [k: string]: unknown; + }, + ]; + /** + * Prefer `Array#{indexOf,lastIndexOf}()` over `Array#{findIndex,findLastIndex}()` when looking for the index of an item. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-array-index-of.md + */ + "eslint-plugin-unicorn/prefer-array-index-of"?: { + [k: string]: unknown; + }; + /** + * Prefer `.some(…)` over `.filter(…).length` check and `.{find,findLast,findIndex,findLastIndex}(…)`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-array-some.md + */ + "eslint-plugin-unicorn/prefer-array-some"?: { + [k: string]: unknown; + }; + /** + * Prefer `.at()` method for index access and `String#charAt()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-at.md + */ + "eslint-plugin-unicorn/prefer-at"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + getLastElementFunctions?: unknown[]; + checkAllIndexAccess?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Prefer `Blob#arrayBuffer()` over `FileReader#readAsArrayBuffer(…)` and `Blob#text()` over `FileReader#readAsText(…)`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-blob-reading-methods.md + */ + "eslint-plugin-unicorn/prefer-blob-reading-methods"?: { + [k: string]: unknown; + }; + /** + * Prefer `String#codePointAt(…)` over `String#charCodeAt(…)` and `String.fromCodePoint(…)` over `String.fromCharCode(…)`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-code-point.md + */ + "eslint-plugin-unicorn/prefer-code-point"?: { + [k: string]: unknown; + }; + /** + * Prefer `Date.now()` to get the number of milliseconds since the Unix Epoch. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-date-now.md + */ + "eslint-plugin-unicorn/prefer-date-now"?: { + [k: string]: unknown; + }; + /** + * Prefer default parameters over reassignment. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-default-parameters.md + */ + "eslint-plugin-unicorn/prefer-default-parameters"?: { + [k: string]: unknown; + }; + /** + * Prefer `Node#append()` over `Node#appendChild()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-dom-node-append.md + */ + "eslint-plugin-unicorn/prefer-dom-node-append"?: { + [k: string]: unknown; + }; + /** + * Prefer using `.dataset` on DOM elements over calling attribute methods. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-dom-node-dataset.md + */ + "eslint-plugin-unicorn/prefer-dom-node-dataset"?: { + [k: string]: unknown; + }; + /** + * Prefer `childNode.remove()` over `parentNode.removeChild(childNode)`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-dom-node-remove.md + */ + "eslint-plugin-unicorn/prefer-dom-node-remove"?: { + [k: string]: unknown; + }; + /** + * Prefer `.textContent` over `.innerText`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-dom-node-text-content.md + */ + "eslint-plugin-unicorn/prefer-dom-node-text-content"?: { + [k: string]: unknown; + }; + /** + * Prefer `EventTarget` over `EventEmitter`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-event-target.md + */ + "eslint-plugin-unicorn/prefer-event-target"?: { + [k: string]: unknown; + }; + /** + * Prefer `export…from` when re-exporting. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-export-from.md + */ + "eslint-plugin-unicorn/prefer-export-from"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + ignoreUsedVariables?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Prefer `.includes()` over `.indexOf()`, `.lastIndexOf()`, and `Array#some()` when checking for existence or non-existence. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-includes.md + */ + "eslint-plugin-unicorn/prefer-includes"?: { + [k: string]: unknown; + }; + /** + * Prefer reading a JSON file as a buffer. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-json-parse-buffer.md + */ + "eslint-plugin-unicorn/prefer-json-parse-buffer"?: { + [k: string]: unknown; + }; + /** + * Prefer `KeyboardEvent#key` over `KeyboardEvent#keyCode`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-keyboard-event-key.md + */ + "eslint-plugin-unicorn/prefer-keyboard-event-key"?: { + [k: string]: unknown; + }; + /** + * Prefer using a logical operator over a ternary. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-logical-operator-over-ternary.md + */ + "eslint-plugin-unicorn/prefer-logical-operator-over-ternary"?: { + [k: string]: unknown; + }; + /** + * Enforce the use of `Math.trunc` instead of bitwise operators. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-math-trunc.md + */ + "eslint-plugin-unicorn/prefer-math-trunc"?: { + [k: string]: unknown; + }; + /** + * Prefer `.before()` over `.insertBefore()`, `.replaceWith()` over `.replaceChild()`, prefer one of `.before()`, `.after()`, `.append()` or `.prepend()` over `insertAdjacentText()` and `insertAdjacentElement()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-modern-dom-apis.md + */ + "eslint-plugin-unicorn/prefer-modern-dom-apis"?: { + [k: string]: unknown; + }; + /** + * Prefer modern `Math` APIs over legacy patterns. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-modern-math-apis.md + */ + "eslint-plugin-unicorn/prefer-modern-math-apis"?: { + [k: string]: unknown; + }; + /** + * Prefer JavaScript modules (ESM) over CommonJS. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-module.md + */ + "eslint-plugin-unicorn/prefer-module"?: { + [k: string]: unknown; + }; + /** + * Prefer using `String`, `Number`, `BigInt`, `Boolean`, and `Symbol` directly. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-native-coercion-functions.md + */ + "eslint-plugin-unicorn/prefer-native-coercion-functions"?: { + [k: string]: unknown; + }; + /** + * Prefer negative index over `.length - index` when possible. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-negative-index.md + */ + "eslint-plugin-unicorn/prefer-negative-index"?: { + [k: string]: unknown; + }; + /** + * Prefer using the `node:` protocol when importing Node.js builtin modules. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-node-protocol.md + */ + "eslint-plugin-unicorn/prefer-node-protocol"?: { + [k: string]: unknown; + }; + /** + * Prefer `Number` static properties over global ones. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-number-properties.md + */ + "eslint-plugin-unicorn/prefer-number-properties"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + checkInfinity?: boolean; + checkNaN?: boolean; + [k: string]: unknown; + }, + ]; + /** + * Prefer using `Object.fromEntries(…)` to transform a list of key-value pairs into an object. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-object-from-entries.md + */ + "eslint-plugin-unicorn/prefer-object-from-entries"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + functions?: unknown[]; + [k: string]: unknown; + }, + ]; + /** + * Prefer omitting the `catch` binding parameter. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-optional-catch-binding.md + */ + "eslint-plugin-unicorn/prefer-optional-catch-binding"?: { + [k: string]: unknown; + }; + /** + * Prefer borrowing methods from the prototype instead of the instance. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-prototype-methods.md + */ + "eslint-plugin-unicorn/prefer-prototype-methods"?: { + [k: string]: unknown; + }; + /** + * Prefer `.querySelector()` over `.getElementById()`, `.querySelectorAll()` over `.getElementsByClassName()` and `.getElementsByTagName()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-query-selector.md + */ + "eslint-plugin-unicorn/prefer-query-selector"?: { + [k: string]: unknown; + }; + /** + * Prefer `Reflect.apply()` over `Function#apply()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-reflect-apply.md + */ + "eslint-plugin-unicorn/prefer-reflect-apply"?: { + [k: string]: unknown; + }; + /** + * Prefer `RegExp#test()` over `String#match()` and `RegExp#exec()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-regexp-test.md + */ + "eslint-plugin-unicorn/prefer-regexp-test"?: { + [k: string]: unknown; + }; + /** + * Prefer `Set#has()` over `Array#includes()` when checking for existence or non-existence. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-set-has.md + */ + "eslint-plugin-unicorn/prefer-set-has"?: { + [k: string]: unknown; + }; + /** + * Prefer using `Set#size` instead of `Array#length`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-set-size.md + */ + "eslint-plugin-unicorn/prefer-set-size"?: { + [k: string]: unknown; + }; + /** + * Prefer the spread operator over `Array.from(…)`, `Array#concat(…)`, `Array#{slice,toSpliced}()` and `String#split('')`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-spread.md + */ + "eslint-plugin-unicorn/prefer-spread"?: { + [k: string]: unknown; + }; + /** + * Prefer using the `String.raw` tag to avoid escaping `\`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-string-raw.md + */ + "eslint-plugin-unicorn/prefer-string-raw"?: { + [k: string]: unknown; + }; + /** + * Prefer `String#replaceAll()` over regex searches with the global flag. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-string-replace-all.md + */ + "eslint-plugin-unicorn/prefer-string-replace-all"?: { + [k: string]: unknown; + }; + /** + * Prefer `String#slice()` over `String#substr()` and `String#substring()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-string-slice.md + */ + "eslint-plugin-unicorn/prefer-string-slice"?: { + [k: string]: unknown; + }; + /** + * Prefer `String#startsWith()` & `String#endsWith()` over `RegExp#test()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-string-starts-ends-with.md + */ + "eslint-plugin-unicorn/prefer-string-starts-ends-with"?: { + [k: string]: unknown; + }; + /** + * Prefer `String#trimStart()` / `String#trimEnd()` over `String#trimLeft()` / `String#trimRight()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-string-trim-start-end.md + */ + "eslint-plugin-unicorn/prefer-string-trim-start-end"?: { + [k: string]: unknown; + }; + /** + * Prefer using `structuredClone` to create a deep clone. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-structured-clone.md + */ + "eslint-plugin-unicorn/prefer-structured-clone"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + functions?: unknown[]; + [k: string]: unknown; + }, + ]; + /** + * Prefer `switch` over multiple `else-if`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-switch.md + */ + "eslint-plugin-unicorn/prefer-switch"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + minimumCases?: number; + emptyDefaultCase?: + | "no-default-comment" + | "do-nothing-comment" + | "no-default-case"; + [k: string]: unknown; + }, + ]; + /** + * Prefer ternary expressions over simple `if-else` statements. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-ternary.md + */ + "eslint-plugin-unicorn/prefer-ternary"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + [k: string]: unknown; + }, + ]; + /** + * Prefer top-level await over top-level promises and async function calls. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-top-level-await.md + */ + "eslint-plugin-unicorn/prefer-top-level-await"?: { + [k: string]: unknown; + }; + /** + * Enforce throwing `TypeError` in type checking conditions. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prefer-type-error.md + */ + "eslint-plugin-unicorn/prefer-type-error"?: { + [k: string]: unknown; + }; + /** + * Prevent abbreviations. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/prevent-abbreviations.md + */ + "eslint-plugin-unicorn/prevent-abbreviations"?: { + [k: string]: unknown; + }; + /** + * Enforce consistent relative URL style. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/relative-url-style.md + */ + "eslint-plugin-unicorn/relative-url-style"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + [k: string]: unknown; + }, + ]; + /** + * Enforce using the separator argument with `Array#join()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/require-array-join-separator.md + */ + "eslint-plugin-unicorn/require-array-join-separator"?: { + [k: string]: unknown; + }; + /** + * Enforce using the digits argument with `Number#toFixed()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/require-number-to-fixed-digits-argument.md + */ + "eslint-plugin-unicorn/require-number-to-fixed-digits-argument"?: { + [k: string]: unknown; + }; + /** + * Enforce using the `targetOrigin` argument with `window.postMessage()`. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/require-post-message-target-origin.md + */ + "eslint-plugin-unicorn/require-post-message-target-origin"?: { + [k: string]: unknown; + }; + /** + * Enforce better string content. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/string-content.md + */ + "eslint-plugin-unicorn/string-content"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + patterns?: { + [k: string]: + | string + | { + suggest: string; + fix?: boolean; + message?: string; + }; + }; + [k: string]: unknown; + }, + ]; + /** + * Enforce consistent brace style for `case` clauses. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/switch-case-braces.md + */ + "eslint-plugin-unicorn/switch-case-braces"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + [k: string]: unknown; + }, + ]; + /** + * Fix whitespace-insensitive template indentation. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/template-indent.md + */ + "eslint-plugin-unicorn/template-indent"?: + | number + | ("off" | "warn" | "error") + | [ + number | ("off" | "warn" | "error"), + { + indent?: string | number; + tags?: string[]; + functions?: string[]; + selectors?: string[]; + comments?: string[]; + [k: string]: unknown; + }, + ]; + /** + * Enforce consistent case for text encoding identifiers. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/text-encoding-identifier-case.md + */ + "eslint-plugin-unicorn/text-encoding-identifier-case"?: { + [k: string]: unknown; + }; + /** + * Require `new` when creating an error. + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/rules/throw-new-error.md + */ + "eslint-plugin-unicorn/throw-new-error"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#import-index + */ + "eslint-plugin-unicorn/import-index"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#no-array-instanceof + */ + "eslint-plugin-unicorn/no-array-instanceof"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#no-fn-reference-in-iterator + */ + "eslint-plugin-unicorn/no-fn-reference-in-iterator"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#no-reduce + */ + "eslint-plugin-unicorn/no-reduce"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#no-unsafe-regex + */ + "eslint-plugin-unicorn/no-unsafe-regex"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#prefer-dataset + */ + "eslint-plugin-unicorn/prefer-dataset"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#prefer-event-key + */ + "eslint-plugin-unicorn/prefer-event-key"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#prefer-exponentiation-operator + */ + "eslint-plugin-unicorn/prefer-exponentiation-operator"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#prefer-flat-map + */ + "eslint-plugin-unicorn/prefer-flat-map"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#prefer-node-append + */ + "eslint-plugin-unicorn/prefer-node-append"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#prefer-node-remove + */ + "eslint-plugin-unicorn/prefer-node-remove"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#prefer-object-has-own + */ + "eslint-plugin-unicorn/prefer-object-has-own"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#prefer-replace-all + */ + "eslint-plugin-unicorn/prefer-replace-all"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#prefer-starts-ends-with + */ + "eslint-plugin-unicorn/prefer-starts-ends-with"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#prefer-text-content + */ + "eslint-plugin-unicorn/prefer-text-content"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#prefer-trim-start-end + */ + "eslint-plugin-unicorn/prefer-trim-start-end"?: { + [k: string]: unknown; + }; + /** + * + * https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v54.0.0/docs/deprecated-rules.md#regex-shorthand + */ + "eslint-plugin-unicorn/regex-shorthand"?: { + [k: string]: unknown; + }; + /** + * Enforce linebreaks after opening and before closing array brackets in `