@terrazzo/parser 2.0.0-alpha.7 → 2.0.0-beta.0

package/src/lib/code-frame.ts

@@ -1,177 +0,0 @@
-// This is copied from @babel/code-frame package but without the heavyweight color highlighting
-// (note: Babel loads both chalk AND picocolors, and doesn’t treeshake well)
-// Babel is MIT-licensed and unaffiliated with this project.
-
-// MIT License
-//
-// Copyright (c) 2014-present Sebastian McKenzie and other contributors
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-export interface Location {
-  line: number;
-  column: number;
-}
-
-export interface NodeLocation {
-  end?: Location;
-  start: Location;
-}
-
-export interface Options {
-  /** Syntax highlight the code as JavaScript for terminals. default: false */
-  highlightCode?: boolean;
-  /**  The number of lines to show above the error. default: 2 */
-  linesAbove?: number;
-  /**  The number of lines to show below the error. default: 3 */
-  linesBelow?: number;
-  /**
-   * Forcibly syntax highlight the code as JavaScript (for non-terminals);
-   * overrides highlightCode.
-   * default: false
-   */
-  forceColor?: boolean;
-  /**
-   * Pass in a string to be displayed inline (if possible) next to the
-   * highlighted location in the code. If it can't be positioned inline,
-   * it will be placed above the code frame.
-   * default: nothing
-   */
-  message?: string;
-}
-
-/**
- * Extract what lines should be marked and highlighted.
- */
-function getMarkerLines(loc: NodeLocation, source: string[], opts: Options = {} as Options) {
-  const startLoc = {
-    // @ts-expect-error this is fine
-    column: 0,
-    // @ts-expect-error this is fine
-    line: -1,
-    ...loc.start,
-  } as Location;
-  const endLoc: Location = {
-    ...startLoc,
-    ...loc.end,
-  };
-  const { linesAbove = 2, linesBelow = 3 } = opts || {};
-  const startLine = startLoc.line;
-  const startColumn = startLoc.column;
-  const endLine = endLoc.line;
-  const endColumn = endLoc.column;
-
-  let start = Math.max(startLine - (linesAbove + 1), 0);
-  let end = Math.min(source.length, endLine + linesBelow);
-
-  if (startLine === -1) {
-    start = 0;
-  }
-
-  if (endLine === -1) {
-    end = source.length;
-  }
-
-  const lineDiff = endLine - startLine;
-  const markerLines: Record<string, any> = {};
-
-  if (lineDiff) {
-    for (let i = 0; i <= lineDiff; i++) {
-      const lineNumber = i + startLine;
-
-      if (!startColumn) {
-        markerLines[lineNumber] = true;
-      } else if (i === 0) {
-        const sourceLength = source[lineNumber - 1]!.length;
-
-        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
-      } else if (i === lineDiff) {
-        markerLines[lineNumber] = [0, endColumn];
-      } else {
-        const sourceLength = source[lineNumber - i]!.length;
-
-        markerLines[lineNumber] = [0, sourceLength];
-      }
-    }
-  } else {
-    if (startColumn === endColumn) {
-      if (startColumn) {
-        markerLines[startLine] = [startColumn, 0];
-      } else {
-        markerLines[startLine] = true;
-      }
-    } else {
-      markerLines[startLine] = [startColumn, endColumn - startColumn];
-    }
-  }
-
-  return { start, end, markerLines };
-}
-
-/**
- * RegExp to test for newlines in terminal.
- */
-
-const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
-
-export function codeFrameColumns(rawLines: string, loc: NodeLocation, opts: Options = {} as Options) {
-  if (typeof rawLines !== 'string') {
-    throw new Error(`Expected string, got ${rawLines}`);
-  }
-  const lines = rawLines.split(NEWLINE);
-  const { start, end, markerLines } = getMarkerLines(loc, lines, opts);
-  const hasColumns = loc.start && typeof loc.start.column === 'number';
-
-  const numberMaxWidth = String(end).length;
-
-  let frame = rawLines
-    .split(NEWLINE, end)
-    .slice(start, end)
-    .map((line, index) => {
-      const number = start + 1 + index;
-      const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
-      const gutter = ` ${paddedNumber} |`;
-      const hasMarker = markerLines[number];
-      const lastMarkerLine = !markerLines[number + 1];
-      if (hasMarker) {
-        let markerLine = '';
-        if (Array.isArray(hasMarker)) {
-          const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, ' ');
-          const numberOfMarkers = hasMarker[1] || 1;
-
-          markerLine = ['\n ', gutter.replace(/\d/g, ' '), ' ', markerSpacing, '^'.repeat(numberOfMarkers)].join('');
-
-          if (lastMarkerLine && opts.message) {
-            markerLine += ` ${opts.message}`;
-          }
-        }
-        return ['>', gutter, line.length > 0 ? ` ${line}` : '', markerLine].join('');
-      } else {
-        return ` ${gutter}${line.length > 0 ? ` ${line}` : ''}`;
-      }
-    })
-    .join('\n');
-
-  if (opts.message && !hasColumns) {
-    frame = `${' '.repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
-  }
-
-  return frame;
-}

package/src/lib/momoa.ts

@@ -1,10 +0,0 @@
-import * as momoa from '@humanwhocodes/momoa';
-
-/** Momoa’s default parser, with preferred settings. */
-export function toMomoa(srcRaw: any): momoa.DocumentNode {
-  return momoa.parse(typeof srcRaw === 'string' ? srcRaw : JSON.stringify(srcRaw, undefined, 2), {
-    mode: 'jsonc',
-    ranges: true,
-    tokens: true,
-  });
-}

package/src/lib/resolver-utils.ts

@@ -1,35 +0,0 @@
-/**
- * If tokens are found inside a resolver, strip out the resolver paths (don’t
- * include "sets"/"modifiers" in the token ID etc.)
- */
-export function filterResolverPaths(path: string[]): string[] {
-  switch (path[0]) {
-    case 'sets': {
-      return path.slice(4);
-    }
-    case 'modifiers': {
-      return path.slice(5);
-    }
-    case 'resolutionOrder': {
-      switch (path[2]) {
-        case 'sources': {
-          return path.slice(4);
-        }
-        case 'contexts': {
-          return path.slice(5);
-        }
-      }
-      break;
-    }
-  }
-  return path;
-}
-
-/**
- * Make a deterministic string from an object
- */
-export function makeInputKey(input: Record<string, string | undefined>): string {
-  return JSON.stringify(
-    Object.fromEntries(Object.entries(input).sort((a, b) => a[0].localeCompare(b[0], 'en-us', { numeric: true }))),
-  );
-}

package/src/lint/index.ts

@@ -1,142 +0,0 @@
-import type { InputSourceWithDocument } from '@terrazzo/json-schema-tools';
-import { pluralize, type TokenNormalizedSet } from '@terrazzo/token-tools';
-import { merge } from 'merge-anything';
-import type { LogEntry, default as Logger } from '../logger.js';
-import type { ConfigInit } from '../types.js';
-
-export { RECOMMENDED_CONFIG } from './plugin-core/index.js';
-
-export interface LintRunnerOptions {
-  tokens: TokenNormalizedSet;
-  filename?: URL;
-  config: ConfigInit;
-  sources: InputSourceWithDocument[];
-  logger: Logger;
-}
-
-export default async function lintRunner({
-  tokens,
-  filename,
-  config = {} as ConfigInit,
-  sources,
-  logger,
-}: LintRunnerOptions): Promise<void> {
-  const { plugins = [], lint } = config;
-  const sourceByFilename: Record<string, InputSourceWithDocument> = {};
-  for (const source of sources) {
-    sourceByFilename[source.filename!.href] = source;
-  }
-  const unusedLintRules = Object.keys(lint?.rules ?? {});
-
-  const errors: LogEntry[] = [];
-  const warnings: LogEntry[] = [];
-  for (const plugin of plugins) {
-    if (typeof plugin.lint === 'function') {
-      const s = performance.now();
-
-      const linter = plugin.lint();
-
-      await Promise.all(
-        Object.entries(linter).map(async ([id, rule]) => {
-          if (!(id in lint.rules) || lint.rules[id] === null) {
-            return;
-          }
-
-          // tick off used rule
-          const unusedLintRuleI = unusedLintRules.indexOf(id);
-          if (unusedLintRuleI !== -1) {
-            unusedLintRules.splice(unusedLintRuleI, 1);
-          }
-
-          const [severity, options] = lint.rules[id]!;
-
-          if (severity === 'off') {
-            return;
-          }
-          // note: this usually isn’t a Promise, but it _might_ be!
-          await rule.create({
-            id,
-            report(descriptor) {
-              let message = '';
-              if (!descriptor.message && !descriptor.messageId) {
-                logger.error({
-                  group: 'lint',
-                  label: `${plugin.name} › lint › ${id}`,
-                  message: 'Unable to report error: missing message or messageId',
-                });
-              }
-
-              // handle message or messageId
-              if (descriptor.message) {
-                message = descriptor.message;
-              } else {
-                if (!(descriptor.messageId! in (rule.meta?.messages ?? {}))) {
-                  logger.error({
-                    group: 'lint',
-                    label: `${plugin.name} › lint › ${id}`,
-                    message: `messageId "${descriptor.messageId}" does not exist`,
-                  });
-                }
-                message = rule.meta?.messages?.[descriptor.messageId as keyof typeof rule.meta.messages] ?? '';
-              }
-
-              // replace with descriptor.data (if any)
-              if (descriptor.data && typeof descriptor.data === 'object') {
-                for (const [k, v] of Object.entries(descriptor.data)) {
-                  // lazy formatting
-                  const formatted = ['string', 'number', 'boolean'].includes(typeof v) ? String(v) : JSON.stringify(v);
-                  message = message.replace(/{{[^}]+}}/g, (inner) => {
-                    const key = inner.substring(2, inner.length - 2).trim();
-                    return key === k ? formatted : inner;
-                  });
-                }
-              }
-
-              (severity === 'error' ? errors : warnings).push({
-                group: 'lint',
-                label: id,
-                message,
-                filename,
-                node: descriptor.node,
-                src: sourceByFilename[descriptor.filename!]?.src,
-              });
-            },
-            tokens,
-            filename,
-            sources,
-            options: merge(
-              rule.meta?.defaultOptions ?? [],
-              rule.defaultOptions ?? [], // Note: is this the correct order to merge in?
-              options,
-            ),
-          });
-        }),
-      );
-
-      logger.debug({
-        group: 'lint',
-        label: plugin.name,
-        message: 'Finished',
-        timing: performance.now() - s,
-      });
-    }
-  }
-
-  const errCount = errors.length ? `${errors.length} ${pluralize(errors.length, 'error', 'errors')}` : '';
-  const warnCount = warnings.length ? `${warnings.length} ${pluralize(warnings.length, 'warning', 'warnings')}` : '';
-  if (errors.length > 0) {
-    logger.error(...errors, {
-      group: 'lint',
-      label: 'lint',
-      message: [errCount, warnCount].filter(Boolean).join(', '),
-    });
-  }
-  if (warnings.length > 0) {
-    logger.warn(...warnings, { group: 'lint', label: 'lint', message: warnCount });
-  }
-
-  // warn user if they have unused lint rules (they might have meant to configure something!)
-  for (const unusedRule of unusedLintRules) {
-    logger.warn({ group: 'lint', label: 'lint', message: `Unknown lint rule "${unusedRule}"` });
-  }
-}

package/src/lint/plugin-core/index.ts

@@ -1,103 +0,0 @@
-// Terrazzo internal plugin that powers lint rules. Always enabled.
-import type { LintRuleLonghand, Plugin } from '../../types.js';
-
-export * from './rules/a11y-min-contrast.js';
-export * from './rules/a11y-min-font-size.js';
-export * from './rules/colorspace.js';
-export * from './rules/consistent-naming.js';
-export * from './rules/descriptions.js';
-export * from './rules/duplicate-values.js';
-export * from './rules/max-gamut.js';
-export * from './rules/required-children.js';
-export * from './rules/required-modes.js';
-export * from './rules/required-type.js';
-export * from './rules/required-typography-properties.js';
-
-import a11yMinContrast, { A11Y_MIN_CONTRAST } from './rules/a11y-min-contrast.js';
-import a11yMinFontSize, { A11Y_MIN_FONT_SIZE } from './rules/a11y-min-font-size.js';
-import colorspace, { COLORSPACE } from './rules/colorspace.js';
-import consistentNaming, { CONSISTENT_NAMING } from './rules/consistent-naming.js';
-import descriptions, { DESCRIPTIONS } from './rules/descriptions.js';
-import duplicateValues, { DUPLICATE_VALUES } from './rules/duplicate-values.js';
-import maxGamut, { MAX_GAMUT } from './rules/max-gamut.js';
-import requiredChildren, { REQUIRED_CHILDREN } from './rules/required-children.js';
-import requiredModes, { REQUIRED_MODES } from './rules/required-modes.js';
-import requiredType, { REQUIRED_TYPE } from './rules/required-type.js';
-import requiredTypographyProperties, {
-  REQUIRED_TYPOGRAPHY_PROPERTIES,
-} from './rules/required-typography-properties.js';
-import validBoolean, { VALID_BOOLEAN } from './rules/valid-boolean.js';
-import validBorder, { VALID_BORDER } from './rules/valid-border.js';
-import validColor, { VALID_COLOR } from './rules/valid-color.js';
-import validCubicBezier, { VALID_CUBIC_BEZIER } from './rules/valid-cubic-bezier.js';
-import validDimension, { VALID_DIMENSION } from './rules/valid-dimension.js';
-import validDuration, { VALID_DURATION } from './rules/valid-duration.js';
-import validFontFamily, { VALID_FONT_FAMILY } from './rules/valid-font-family.js';
-import validFontWeight, { VALID_FONT_WEIGHT } from './rules/valid-font-weight.js';
-import validGradient, { VALID_GRADIENT } from './rules/valid-gradient.js';
-import validLink, { VALID_LINK } from './rules/valid-link.js';
-import validNumber, { VALID_NUMBER } from './rules/valid-number.js';
-import validShadow, { VALID_SHADOW } from './rules/valid-shadow.js';
-import validString, { VALID_STRING } from './rules/valid-string.js';
-import validStrokeStyle, { VALID_STROKE_STYLE } from './rules/valid-stroke-style.js';
-import validTransition, { VALID_TRANSITION } from './rules/valid-transition.js';
-import validTypography, { VALID_TYPOGRAPHY } from './rules/valid-typography.js';
-
-const ALL_RULES = {
-  [VALID_COLOR]: validColor,
-  [VALID_DIMENSION]: validDimension,
-  [VALID_FONT_FAMILY]: validFontFamily,
-  [VALID_FONT_WEIGHT]: validFontWeight,
-  [VALID_DURATION]: validDuration,
-  [VALID_CUBIC_BEZIER]: validCubicBezier,
-  [VALID_NUMBER]: validNumber,
-  [VALID_LINK]: validLink,
-  [VALID_BOOLEAN]: validBoolean,
-  [VALID_STRING]: validString,
-  [VALID_STROKE_STYLE]: validStrokeStyle,
-  [VALID_BORDER]: validBorder,
-  [VALID_TRANSITION]: validTransition,
-  [VALID_SHADOW]: validShadow,
-  [VALID_GRADIENT]: validGradient,
-  [VALID_TYPOGRAPHY]: validTypography,
-  [COLORSPACE]: colorspace,
-  [CONSISTENT_NAMING]: consistentNaming,
-  [DESCRIPTIONS]: descriptions,
-  [DUPLICATE_VALUES]: duplicateValues,
-  [MAX_GAMUT]: maxGamut,
-  [REQUIRED_CHILDREN]: requiredChildren,
-  [REQUIRED_MODES]: requiredModes,
-  [REQUIRED_TYPE]: requiredType,
-  [REQUIRED_TYPOGRAPHY_PROPERTIES]: requiredTypographyProperties,
-  [A11Y_MIN_CONTRAST]: a11yMinContrast,
-  [A11Y_MIN_FONT_SIZE]: a11yMinFontSize,
-};
-
-export default function coreLintPlugin(): Plugin {
-  return {
-    name: '@terrazzo/plugin-lint-core',
-    lint() {
-      return ALL_RULES;
-    },
-  };
-}
-
-export const RECOMMENDED_CONFIG: Record<string, LintRuleLonghand> = {
-  [VALID_COLOR]: ['error', {}],
-  [VALID_DIMENSION]: ['error', {}],
-  [VALID_FONT_FAMILY]: ['error', {}],
-  [VALID_FONT_WEIGHT]: ['error', {}],
-  [VALID_DURATION]: ['error', {}],
-  [VALID_CUBIC_BEZIER]: ['error', {}],
-  [VALID_NUMBER]: ['error', {}],
-  [VALID_LINK]: ['error', {}],
-  [VALID_BOOLEAN]: ['error', {}],
-  [VALID_STRING]: ['error', {}],
-  [VALID_STROKE_STYLE]: ['error', {}],
-  [VALID_BORDER]: ['error', {}],
-  [VALID_TRANSITION]: ['error', {}],
-  [VALID_SHADOW]: ['error', {}],
-  [VALID_GRADIENT]: ['error', {}],
-  [VALID_TYPOGRAPHY]: ['error', {}],
-  [CONSISTENT_NAMING]: ['warn', { format: 'kebab-case' }],
-};

package/src/lint/plugin-core/lib/docs.ts

@@ -1,3 +0,0 @@
-export function docsLink(ruleName: string): string {
-  return `https://terrazzo.app/docs/linting#${ruleName.replaceAll('/', '')}`;
-}

package/src/lint/plugin-core/rules/a11y-min-contrast.ts

@@ -1,91 +0,0 @@
-import { tokenToCulori } from '@terrazzo/token-tools';
-import { wcagContrast } from 'culori';
-import type { LintRule } from '../../../types.js';
-import { docsLink } from '../lib/docs.js';
-
-export const A11Y_MIN_CONTRAST = 'a11y/min-contrast';
-
-export interface RuleA11yMinContrastOptions {
-  /**
-   * Whether to adhere to AA (minimum) or AAA (enhanced) contrast levels.
-   * @default "AA"
-   */
-  level?: 'AA' | 'AAA';
-  /** Pairs of color tokens (and optionally typography) to test */
-  pairs: ContrastPair[];
-}
-
-export interface ContrastPair {
-  /** The foreground color token ID */
-  foreground: string;
-  /** The background color token ID */
-  background: string;
-  /**
-   * Is this pair for large text? Large text allows a smaller contrast ratio.
-   *
-   * Note: while WCAG has _suggested_ sizes and weights, those are merely
-   * suggestions. It’s always more reliable to determine what constitutes “large
-   * text” for your designs yourself, based on your typographic stack.
-   * @see https://www.w3.org/WAI/WCAG22/quickref/#contrast-minimum
-   */
-  largeText?: boolean;
-}
-
-export const WCAG2_MIN_CONTRAST = {
-  AA: { default: 4.5, large: 3 },
-  AAA: { default: 7, large: 4.5 },
-};
-
-export const ERROR_INSUFFICIENT_CONTRAST = 'INSUFFICIENT_CONTRAST';
-
-const rule: LintRule<typeof ERROR_INSUFFICIENT_CONTRAST, RuleA11yMinContrastOptions> = {
-  meta: {
-    messages: {
-      [ERROR_INSUFFICIENT_CONTRAST]: 'Pair {{ index }} failed; expected {{ expected }}, got {{ actual }} ({{ level }})',
-    },
-    docs: {
-      description: 'Enforce colors meet minimum contrast checks for WCAG 2.',
-      url: docsLink(A11Y_MIN_CONTRAST),
-    },
-  },
-  defaultOptions: { level: 'AA', pairs: [] },
-  create({ tokens, options, report }) {
-    for (let i = 0; i < options.pairs.length; i++) {
-      const { foreground, background, largeText } = options.pairs[i]!;
-      if (!tokens[foreground]) {
-        throw new Error(`Token ${foreground} does not exist`);
-      }
-      if (tokens[foreground].$type !== 'color') {
-        throw new Error(`Token ${foreground} isn’t a color`);
-      }
-      if (!tokens[background]) {
-        throw new Error(`Token ${background} does not exist`);
-      }
-      if (tokens[background].$type !== 'color') {
-        throw new Error(`Token ${background} isn’t a color`);
-      }
-
-      // Note: if these culors were unparseable, they would have already thrown an error before the linter
-      const a = tokenToCulori(tokens[foreground].$value)!;
-      const b = tokenToCulori(tokens[background].$value)!;
-
-      // Note: for the purposes of WCAG 2, foreground and background don’t
-      // matter. But in other contrast algorithms, they do.
-      const contrast = wcagContrast(a, b);
-      const min = WCAG2_MIN_CONTRAST[options.level ?? 'AA'][largeText ? 'large' : 'default'];
-      if (contrast < min) {
-        report({
-          messageId: ERROR_INSUFFICIENT_CONTRAST,
-          data: {
-            index: i + 1,
-            expected: min,
-            actual: Math.round(contrast * 100) / 100,
-            level: options.level,
-          },
-        });
-      }
-    }
-  },
-};
-
-export default rule;

package/src/lint/plugin-core/rules/a11y-min-font-size.ts

@@ -1,66 +0,0 @@
-import wcmatch from 'wildcard-match';
-import type { LintRule } from '../../../types.js';
-import { docsLink } from '../lib/docs.js';
-
-export const A11Y_MIN_FONT_SIZE = 'a11y/min-font-size';
-
-export interface RuleA11yMinFontSizeOptions {
-  /** Minimum font size (pixels) */
-  minSizePx?: number;
-  /** Minimum font size (rems) */
-  minSizeRem?: number;
-  /** Token IDs to ignore. Accepts globs. */
-  ignore?: string[];
-}
-
-export const ERROR_TOO_SMALL = 'TOO_SMALL';
-
-const rule: LintRule<typeof ERROR_TOO_SMALL, RuleA11yMinFontSizeOptions> = {
-  meta: {
-    messages: {
-      [ERROR_TOO_SMALL]: '{{ id }} font size too small. Expected minimum of {{ min }}',
-    },
-    docs: {
-      description: 'Enforce font sizes are no smaller than the given value.',
-      url: docsLink(A11Y_MIN_FONT_SIZE),
-    },
-  },
-  defaultOptions: {},
-  create({ tokens, options, report }) {
-    if (!options.minSizePx && !options.minSizeRem) {
-      throw new Error('Must specify at least one of minSizePx or minSizeRem');
-    }
-
-    const shouldIgnore = options.ignore ? wcmatch(options.ignore) : null;
-
-    for (const t of Object.values(tokens)) {
-      if (shouldIgnore?.(t.id)) {
-        continue;
-      }
-
-      // skip aliases
-      if (t.aliasOf) {
-        continue;
-      }
-
-      if (t.$type === 'typography' && 'fontSize' in t.$value) {
-        const fontSize = t.$value.fontSize!;
-
-        if (
-          (fontSize.unit === 'px' && options.minSizePx && fontSize.value < options.minSizePx) ||
-          (fontSize.unit === 'rem' && options.minSizeRem && fontSize.value < options.minSizeRem)
-        ) {
-          report({
-            messageId: ERROR_TOO_SMALL,
-            data: {
-              id: t.id,
-              min: options.minSizePx ? `${options.minSizePx}px` : `${options.minSizeRem}rem`,
-            },
-          });
-        }
-      }
-    }
-  },
-};
-
-export default rule;