@markuplint/ml-config 4.8.14 → 5.0.0-alpha.0

package/lib/merge-config.js

@@ -1,11 +1,25 @@
-import deepmerge from 'deepmerge';
-import { deleteUndefProp, cleanOptions, isRuleConfigValue } from './utils.js';
+import { deleteUndefProp, cleanOptions, isRuleConfigValue, isNamedRuleGroup } from './utils.js';
+/**
+ * Merges two markuplint configurations into an optimized result.
+ *
+ * Plugins, arrays, and rules are merged with specific strategies:
+ * - Plugins are concatenated and deduplicated by name (settings shallow-merged)
+ * - Arrays (excludeFiles, nodeRules, childNodeRules) are concatenated
+ * - Rules are merged per-key with right-side precedence
+ * - Objects (parser, specs, etc.) are shallow-merged
+ * - The `extends` property is removed from the result when `b` is provided
+ *
+ * @param a - The base configuration
+ * @param b - The configuration to merge on top of `a`
+ * @returns The merged and optimized configuration
+ */
 export function mergeConfig(a, b) {
     const deleteExtendsProp = !!b;
     b = b ?? {};
     const config = {
         ...a,
         ...b,
+        ruleCommonSettings: mergeObject(a.ruleCommonSettings, b.ruleCommonSettings),
         plugins: concatArray(a.plugins, b.plugins, true, 'name')?.map(plugin => {
             if (typeof plugin === 'string') {
                 return {
@@ -23,8 +37,8 @@ export function mergeConfig(a, b) {
         rules: mergeRules(
         // TODO: Deep merge
         a.rules, b.rules),
-        nodeRules: concatArray(a.nodeRules, b.nodeRules),
-        childNodeRules: concatArray(a.childNodeRules, b.childNodeRules),
+        nodeRules: concatArray(a.nodeRules, b.nodeRules, true, 'name'),
+        childNodeRules: concatArray(a.childNodeRules, b.childNodeRules, true, 'name'),
         overrideMode: b.overrideMode ?? a.overrideMode,
         overrides: mergeOverrides(a.overrides, b.overrides),
         extends: concatArray(toReadonlyArray(a.extends), toReadonlyArray(b.extends)),
@@ -36,6 +50,18 @@ export function mergeConfig(a, b) {
     deleteUndefProp(config);
     return config;
 }
+/**
+ * Merges two rule configurations with right-side precedence.
+ *
+ * If `b` is `false`, the rule is unconditionally disabled.
+ * If `b` is a direct value (including arrays), it overrides `a`.
+ * If both are full config objects, their properties are merged
+ * (severity/value/reason: right-side wins, options: shallow-merged).
+ *
+ * @param a - The base rule configuration (may be `null` or `undefined`)
+ * @param b - The rule configuration to merge on top
+ * @returns The merged rule configuration
+ */
 export function mergeRule(a, b) {
     const oA = optimizeRule(a);
     const oB = optimizeRule(b);
@@ -53,13 +79,9 @@ export function mergeRule(a, b) {
     }
     if (isRuleConfigValue(oB)) {
         if (isRuleConfigValue(oA)) {
-            if (Array.isArray(oA) && Array.isArray(oB)) {
-                return [...oA, ...oB];
-            }
             return oB;
         }
-        const value = Array.isArray(oA.value) && Array.isArray(oB) ? [...oA.value, ...oB] : oB;
-        const res = cleanOptions({ ...oA, value });
+        const res = cleanOptions({ ...oA, value: oB });
         deleteUndefProp(res);
         return res;
     }
@@ -80,13 +102,25 @@ function mergePretenders(a, b) {
     if (!a && !b) {
         return;
     }
-    const aDetails = a ? convertPretenersToDetails(a) : undefined;
-    const bDetails = b ? convertPretenersToDetails(b) : undefined;
-    const details = mergeObject(aDetails, bDetails) ?? {};
+    const aDetails = a ? toPretenderDetails(a) : undefined;
+    const bDetails = b ? toPretenderDetails(b) : undefined;
+    if (!aDetails) {
+        return bDetails;
+    }
+    if (!bDetails) {
+        return aDetails;
+    }
+    // files/imports: override (right-side wins)
+    // data: append (concatenate)
+    const details = {
+        files: bDetails.files ?? aDetails.files,
+        imports: bDetails.imports ?? aDetails.imports,
+        data: concatArray(aDetails.data, bDetails.data),
+    };
     deleteUndefProp(details);
     return details;
 }
-function convertPretenersToDetails(pretenders) {
+function toPretenderDetails(pretenders) {
     if (isReadonlyArray(pretenders)) {
         return {
             data: pretenders,
@@ -124,7 +158,7 @@ function mergeObject(a, b) {
     if (b == null) {
         return a ?? undefined;
     }
-    const res = deepmerge(a, b);
+    const res = { ...a, ...b };
     deleteUndefProp(res);
     return res;
 }
@@ -156,12 +190,7 @@ function concatArray(a, b, uniquely = false, comparePropName) {
             return;
         }
         const existed = newArray[existedIndex];
-        const merged = mergeObject(existed, item);
-        if (!merged) {
-            newArray.push(item);
-            return;
-        }
-        newArray.splice(existedIndex, 1, merged);
+        newArray.splice(existedIndex, 1, { ...existed, ...item });
     }
     // eslint-disable-next-line unicorn/no-array-for-each
     a?.forEach(concat);
@@ -181,6 +210,15 @@ function getName(item, comparePropName) {
     }
     return null;
 }
+/**
+ * Merges two Rules dictionaries. Keys containing `/` use named rule group
+ * merge semantics ({@link mergeNamedRuleGroupEntry}); other keys use standard
+ * rule merge semantics ({@link mergeRule}).
+ *
+ * @param a - The base rules (lower priority)
+ * @param b - The override rules (higher priority)
+ * @returns The merged rules, or `undefined` if both inputs are nullish
+ */
 function mergeRules(a, b) {
     if (a == null) {
         return b && optimizeRules(b);
@@ -190,17 +228,62 @@ function mergeRules(a, b) {
     }
     const res = optimizeRules(a);
     for (const [key, rule] of Object.entries(b)) {
-        const merged = mergeRule(res[key], rule);
-        if (merged != null) {
-            res[key] = merged;
+        if (key.includes('/')) {
+            // Named rule group key: special merge semantics
+            res[key] = mergeNamedRuleGroupEntry(res[key], rule);
+        }
+        else {
+            const merged = mergeRule(res[key], rule);
+            if (merged != null) {
+                res[key] = merged;
+            }
         }
     }
     deleteUndefProp(res);
     return Object.freeze(res);
 }
+/**
+ * Merges a named rule group entry (key containing `/`).
+ *
+ * - `false` disables the group entirely
+ * - A partial override object (e.g., `{ severity: "warning" }`) is merged into the existing NamedRuleGroup
+ * - Otherwise, right side wins
+ *
+ * @param a - The existing entry from a lower-priority config (may be a NamedRuleGroup)
+ * @param b - The overriding entry from a higher-priority config
+ * @returns The merged entry
+ */
+function mergeNamedRuleGroupEntry(a, b) {
+    // false disables the group
+    if (b === false) {
+        return false;
+    }
+    // Partial override: object without `rules` merging into an existing NamedRuleGroup
+    // Only merge valid NamedRuleGroup keys to avoid contamination from RuleConfig keys
+    if (typeof b === 'object' && b !== null && !isNamedRuleGroup(b) && a !== undefined && isNamedRuleGroup(a)) {
+        const bObj = b;
+        const override = {};
+        if ('severity' in bObj) {
+            override.severity = bObj.severity;
+        }
+        if ('specConformance' in bObj) {
+            override.specConformance = bObj.specConformance;
+        }
+        const merged = { ...a, ...override };
+        deleteUndefProp(merged);
+        return merged;
+    }
+    // Right side wins for everything else
+    return b;
+}
 function optimizeRules(rules) {
     const res = {};
     for (const [key, rule] of Object.entries(rules)) {
+        // Pass through NamedRuleGroup entries without optimization
+        if (key.includes('/') && isNamedRuleGroup(rule)) {
+            res[key] = rule;
+            continue;
+        }
         const _rule = optimizeRule(rule);
         if (_rule != null) {
             res[key] = _rule;

package/lib/types.d.ts

@@ -1,9 +1,15 @@
 import type { ParserOptions } from '@markuplint/ml-ast';
+import type { ARIAVersion } from '@markuplint/ml-spec';
 import type { RegexSelector } from '@markuplint/selector';
 import type { Nullable } from '@markuplint/shared';
 export type { RegexSelector } from '@markuplint/selector';
+/**
+ * The root configuration object for markuplint.
+ * Defines rules, parsers, specs, plugins, and overrides for linting markup.
+ */
 export type Config = {
     readonly $schema?: string;
+    readonly ruleCommonSettings?: RuleCommonSettings;
     readonly extends?: string | readonly string[];
     readonly plugins?: readonly (PluginConfig | string)[];
     readonly parser?: ParserConfig;
@@ -18,35 +24,79 @@ export type Config = {
     readonly overrideMode?: 'merge' | 'reset';
     readonly overrides?: Readonly<Record<string, OverrideConfig>>;
 };
+/**
+ * Common settings applied globally to all rules.
+ * These values serve as fallbacks when individual rules do not specify their own.
+ */
+export type RuleCommonSettings = {
+    readonly ariaVersion?: ARIAVersion;
+};
+/**
+ * A primitive scalar value that can appear in rule configuration.
+ */
 export type PrimitiveScalar = string | number | boolean;
+/**
+ * A JSON-compatible data structure used for rule options and plugin settings.
+ * Can be a primitive, null/undefined, an array of `PlainData`, or a plain object.
+ */
 export type PlainData = Nullable<PrimitiveScalar> | readonly PlainData[] | {
     readonly [key: string]: PlainData | any;
 };
+/**
+ * A non-nullable variant of {@link PlainData}, excluding `null` and `undefined`.
+ */
 export type NonNullablePlainData = PrimitiveScalar | readonly NonNullablePlainData[] | {
     readonly [key: string]: NonNullablePlainData;
 };
 type NoInherit = '$schema' | 'extends' | 'overrideMode' | 'overrides';
+/**
+ * Configuration applied to specific file patterns via the `overrides` field.
+ * Excludes top-level-only properties like `$schema`, `extends`, `overrideMode`, and `overrides`.
+ */
 export type OverrideConfig = Omit<Config, NoInherit>;
+/**
+ * A fully resolved and optimized configuration after merging.
+ * Plugins are normalized to objects, and pretenders are converted to {@link PretenderDetails}.
+ */
 export type OptimizedConfig = Omit<Config, '$schema' | 'extends' | 'plugins' | 'pretenders' | 'overrides'> & {
     readonly extends?: readonly string[];
     readonly plugins?: readonly PluginConfig[];
     readonly pretenders?: PretenderDetails;
     readonly overrides?: Readonly<Record<string, OptimizedOverrideConfig>>;
 };
+/**
+ * An optimized override configuration, excluding top-level-only properties.
+ */
 export type OptimizedOverrideConfig = Omit<OptimizedConfig, NoInherit>;
+/**
+ * Configuration for a single markuplint plugin.
+ */
 export type PluginConfig = {
     readonly name: string;
     readonly settings?: Readonly<Record<string, NonNullablePlainData>>;
 };
+/**
+ * Maps file extension patterns to parser module names or paths.
+ */
 export type ParserConfig = {
     readonly [extensionPattern: string]: string;
 };
+/**
+ * Maps file extension patterns to spec module names or paths.
+ */
 export type SpecConfig = {
     readonly [extensionPattern: string]: string;
 };
+/**
+ * Options for controlling the severity of specific diagnostic categories.
+ */
 export type SeverityOptions = {
     readonly parseError?: Severity | 'off' | boolean;
 };
+/**
+ * Normalized form of pretender configuration used after merging.
+ * Contains optional file references, import paths, and inline pretender data.
+ */
 export type PretenderDetails = {
     /**
      * @experimental
@@ -58,10 +108,18 @@ export type PretenderDetails = {
     readonly imports?: readonly string[];
     readonly data?: readonly Pretender[];
 };
+/**
+ * Data structure for a pretender definition file.
+ */
 export type PretenderFileData = {
     readonly version: string;
     readonly data: readonly Pretender[];
 };
+/**
+ * Defines a mapping from a custom element (matched by CSS selector) to a standard
+ * HTML element for linting purposes, allowing rules to treat custom components
+ * as if they were native elements.
+ */
 export type Pretender = {
     /**
      * Target node selectors
@@ -218,82 +276,209 @@ export interface PretenderScanOptions {
     readonly cwd?: string;
     readonly ignoreComponentNames?: readonly string[];
 }
+/**
+ * A rule setting: either a full {@link RuleConfig} object, a direct value, or a boolean to enable/disable.
+ *
+ * @template T - The type of the rule's value
+ * @template O - The type of the rule's options
+ */
 export type Rule<T extends RuleConfigValue, O extends PlainData = undefined> = RuleConfig<T, O> | Readonly<T> | boolean;
 /**
- * @deprecated
+ * A rule setting with any value and option types.
  */
-export type RuleV2<T extends RuleConfigValue, O extends PlainData = undefined> = RuleConfigV2<T, O> | Readonly<T> | boolean;
 export type AnyRule = Rule<RuleConfigValue, PlainData>;
 /**
- * @deprecated
+ * A named rule group in the `rules` section.
+ * Keys containing `/` in `rules` are treated as named rule groups.
+ * Each group wraps one or more base rules under a namespace,
+ * enabling per-check control and spec conformance metadata.
+ *
+ * @example
+ * ```jsonc
+ * {
+ *   "rules": {
+ *     "a11y/id-duplication": {
+ *       "specConformance": "normative",
+ *       "rules": { "id-duplication": true }
+ *     }
+ *   }
+ * }
+ * ```
  */
-export type AnyRuleV2 = RuleV2<RuleConfigValue, PlainData>;
-export type Rules = {
+export type NamedRuleGroup = {
+    readonly specConformance?: SpecConformance;
+    /** User-applied severity override for all rules in the group */
+    readonly severity?: Severity;
+    readonly rules: BaseRules;
+};
+/**
+ * A dictionary mapping base rule names to their configurations.
+ * Does not accept {@link NamedRuleGroup} entries.
+ * Used inside {@link NamedRuleGroup}, {@link NodeRule}, and {@link ChildNodeRule}.
+ */
+export type BaseRules = {
     readonly [ruleName: string]: AnyRule;
 };
+/**
+ * A dictionary mapping rule names to their configurations.
+ * Keys containing `/` may be {@link NamedRuleGroup} entries.
+ */
+export type Rules = {
+    readonly [ruleName: string]: AnyRule | NamedRuleGroup;
+};
+/**
+ * Full configuration for a single rule, specifying severity, value, options, and reason.
+ *
+ * @template T - The type of the rule's value
+ * @template O - The type of the rule's options
+ */
 export type RuleConfig<T extends RuleConfigValue, O extends PlainData = undefined> = {
+    /** The severity level for violations of this rule */
     readonly severity?: Severity;
+    /** The rule's primary configuration value */
     readonly value?: Readonly<T>;
+    /** Additional options for the rule */
     readonly options?: Readonly<O>;
+    /** A human-readable reason for this rule configuration, included in violation messages */
     readonly reason?: string;
 };
 /**
- * @deprecated
+ * The severity level of a lint violation.
  */
-export type RuleConfigV2<T extends RuleConfigValue, O extends PlainData = undefined> = {
-    readonly severity?: Severity;
-    readonly value?: Readonly<T>;
-    readonly reason?: string;
-    /**
-     * Old property
-     *
-     * @deprecated
-     * @see {this.options}
-     */
-    readonly option?: Readonly<O>;
-};
 export type Severity = 'error' | 'warning' | 'info';
+/**
+ * The spec conformance classification of a rule, based on RFC 2119 keyword strength.
+ *
+ * - `'normative'` — derived from MUST/REQUIRED requirements in the HTML spec
+ * - `'non-normative'` — derived from SHOULD/RECOMMENDED requirements in the HTML spec
+ * - `undefined` — plugin/preset recommendation or user-defined (no spec backing)
+ */
+export type SpecConformance = 'normative' | 'non-normative';
+/**
+ * The value portion of a rule configuration. Can be a primitive scalar,
+ * an array of scalars or objects, or `null` to represent no value.
+ */
 export type RuleConfigValue = PrimitiveScalar | readonly (PrimitiveScalar | Readonly<Record<string, any>>)[] | null;
+/**
+ * A rule override that targets specific nodes by CSS selector, regex selector, ARIA roles, or categories.
+ *
+ * When a `name` is provided (must contain `/`), this becomes a **named nodeRule**
+ * that creates a virtual rule instance running independently from the base rule.
+ * Named nodeRules can be individually enabled/disabled via `rules["name/here"]: false`.
+ */
 export type NodeRule = {
+    /**
+     * Alias name for this nodeRule, creating a virtual rule.
+     * Must contain `/` (e.g., `"a11y/img-has-alt"`).
+     * With a single non-false entry, this name is used directly.
+     * With multiple non-false entries, derived names (`name/baseRuleName`)
+     * are generated automatically, and this name becomes the group name.
+     */
+    readonly name?: string;
+    /**
+     * The spec conformance classification of this rule.
+     * Included in violations as metadata for downstream tools and reporting.
+     */
+    readonly specConformance?: SpecConformance;
     readonly selector?: string;
     readonly regexSelector?: RegexSelector;
     readonly categories?: readonly string[];
     readonly roles?: readonly string[];
     readonly obsolete?: boolean;
-    readonly rules?: Rules;
+    /** Base rule settings. Does not accept {@link NamedRuleGroup} entries. */
+    readonly rules?: BaseRules;
 };
+/**
+ * A rule override that targets child nodes of elements matching the selector.
+ *
+ * When a `name` is provided (must contain `/`), this becomes a **named childNodeRule**
+ * that creates a virtual rule instance, just like named nodeRules.
+ */
 export type ChildNodeRule = {
+    /**
+     * Alias name for this childNodeRule, creating a virtual rule.
+     * Must contain `/` (e.g., `"a11y/heading-in-section"`).
+     * With a single non-false entry, this name is used directly.
+     * With multiple non-false entries, derived names (`name/baseRuleName`)
+     * are generated automatically, and this name becomes the group name.
+     */
+    readonly name?: string;
+    /**
+     * The spec conformance classification of this rule.
+     * Included in violations as metadata for downstream tools and reporting.
+     */
+    readonly specConformance?: SpecConformance;
     readonly selector?: string;
     readonly regexSelector?: RegexSelector;
     readonly inheritance?: boolean;
-    readonly rules?: Rules;
+    /** Base rule settings. Does not accept {@link NamedRuleGroup} entries. */
+    readonly rules?: BaseRules;
 };
+/**
+ * A violation report from a rule. Can report against a scope (node-based)
+ * or against explicit line/column coordinates, or both.
+ *
+ * @template T - The type of the rule's value
+ * @template O - The type of the rule's options
+ */
 export type Report<T extends RuleConfigValue, O extends PlainData = undefined> = Report1<T, O> | Report2 | (Report1<T, O> & Report2);
+/**
+ * A scope-based violation report, referencing the rule info and position via a {@link Scope}.
+ *
+ * @template T - The type of the rule's value
+ * @template O - The type of the rule's options
+ */
 export type Report1<T extends RuleConfigValue, O extends PlainData = undefined> = {
     readonly message: string;
     readonly scope: Scope<T, O>;
 };
+/**
+ * A coordinate-based violation report with explicit line, column, and raw text.
+ */
 export type Report2 = {
     readonly message: string;
     readonly line: number;
     readonly col: number;
     readonly raw: string;
 };
+/**
+ * Identifies the location and rule context of a reported violation.
+ *
+ * @template T - The type of the rule's value
+ * @template O - The type of the rule's options
+ */
 export type Scope<T extends RuleConfigValue, O extends PlainData = undefined> = {
     readonly rule: RuleInfo<T, O>;
     readonly startLine: number;
     readonly startCol: number;
     readonly raw: string;
 };
+/**
+ * A fully resolved lint violation with all information needed for reporting.
+ */
 export type Violation = {
+    /** The base rule ID (always the underlying rule name, for backwards compatibility) */
     readonly ruleId: string;
+    /**
+     * The display name of the rule. Present only on virtual rules (named nodeRules).
+     * For regular rules, use `ruleId` as the display name.
+     */
+    readonly name?: string;
     readonly severity: Severity;
     readonly message: string;
     readonly reason?: string;
+    /** The normative level of the rule that produced this violation */
+    readonly specConformance?: SpecConformance;
     readonly line: number;
     readonly col: number;
     readonly raw: string;
 };
+/**
+ * Resolved rule information after configuration merging, used at runtime by rules.
+ *
+ * @template T - The type of the rule's value
+ * @template O - The type of the rule's options
+ */
 export type RuleInfo<T extends RuleConfigValue, O extends PlainData = undefined> = {
     readonly disabled: boolean;
     readonly severity: Severity;
@@ -301,6 +486,12 @@ export type RuleInfo<T extends RuleConfigValue, O extends PlainData = undefined>
     readonly options: Readonly<O>;
     readonly reason?: string;
 };
+/**
+ * Extended rule information that includes node-level and child-node-level overrides.
+ *
+ * @template T - The type of the rule's value
+ * @template O - The type of the rule's options
+ */
 export type GlobalRuleInfo<T extends RuleConfigValue, O extends PlainData = undefined> = RuleInfo<T, O> & {
     nodeRules: RuleInfo<T, O>[];
     childNodeRules: RuleInfo<T, O>[];

package/lib/utils.d.ts

@@ -1,18 +1,59 @@
-import type { AnyRule, AnyRuleV2, PlainData, RuleConfig, RuleConfigV2, RuleConfigValue } from './types.js';
+import type { AnyRule, NamedRuleGroup, PlainData, RuleConfig, RuleConfigValue, Severity } from './types.js';
 /**
- * Return undefined if the template doesn't include the variable that is set as a property in data.
- * But return template string without changes if it doesn't have a variable.
+ * Renders a Mustache template with the provided data.
  *
- * @param template Mustache template string
- * @param data Captured string for replacement
+ * Returns `undefined` if the template contains variables but none of them
+ * are present in `data`. Returns the template unchanged if it has no variables.
+ *
+ * @param template - A Mustache template string with `{{variable}}` placeholders
+ * @param data - Key-value pairs for template variable replacement
+ * @returns The rendered string, or `undefined` if no matching variables were found
  */
 export declare function provideValue(template: string, data: Readonly<Record<string, string>>): string | undefined;
-export declare function exchangeValueOnRule(rule: AnyRule | AnyRuleV2, data: Readonly<Record<string, string>>): AnyRule | undefined;
-export declare function cleanOptions(rule: RuleConfig<RuleConfigValue, PlainData> | RuleConfigV2<RuleConfigValue, PlainData>): RuleConfig<RuleConfigValue, PlainData>;
+/**
+ * Applies Mustache template rendering to all string values within a rule configuration,
+ * including the rule's value, options, and reason fields.
+ *
+ * @param rule - The rule configuration containing potential template strings
+ * @param data - Key-value pairs for template variable replacement
+ * @returns The rule with all template strings rendered, or `undefined` if rendering fails
+ */
+export declare function exchangeValueOnRule(rule: AnyRule, data: Readonly<Record<string, string>>): AnyRule | undefined;
+/**
+ * Normalizes a rule configuration by extracting the standard fields
+ * (`severity`, `value`, `options`, `reason`) and removing `undefined` properties.
+ *
+ * @param rule - The rule configuration to normalize
+ * @returns A clean rule configuration with only defined properties
+ */
+export declare function cleanOptions(rule: RuleConfig<RuleConfigValue, PlainData>): RuleConfig<RuleConfigValue, PlainData>;
+/**
+ * Type guard that checks whether a value is a {@link NamedRuleGroup}.
+ * A NamedRuleGroup is an object with a `rules` property (and optionally `specConformance` and `severity`).
+ *
+ * @param v - The value to check
+ * @returns `true` if `v` is a named rule group
+ */
+export declare function isNamedRuleGroup(v: unknown): v is NamedRuleGroup;
+/**
+ * Type guard that checks whether a string is a valid {@link Severity} value.
+ *
+ * @param v - The string to check
+ * @returns `true` if `v` is "error", "warning", or "info"
+ */
+export declare function isSeverity(v: string): v is Severity;
+/**
+ * Type guard that checks whether a value is a {@link RuleConfigValue}
+ * (i.e. a primitive, `null`, or an array) rather than a full {@link RuleConfig} object.
+ *
+ * @param v - The value to check
+ * @returns `true` if `v` is a rule config value (string, number, boolean, null, or array)
+ */
 export declare function isRuleConfigValue(v: any): v is RuleConfigValue;
 /**
+ * Removes all properties with `undefined` values from a plain object in-place.
+ * Has no effect on non-plain-object values.
  *
- * @param obj
- * @returns
+ * @param obj - The object to clean up
  */
 export declare function deleteUndefProp(obj: any): void;