@askviraj/linter 1.1.4 → 1.1.6

package/node_modules/@rviscomi/capo.js/src/lib/validations/viewport.js

@@ -0,0 +1,183 @@
+/**
+ * @typedef {import('../../adapters/adapter.js').AdapterInterface} AdapterInterface
+ * @typedef {import('../validation.js').CustomValidationResult} CustomValidationResult
+ */
+
+/**
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {boolean}
+ */
+export function isMetaViewport(element, adapter) {
+  if (adapter.getTagName(element) !== "meta") return false;
+  const name = adapter.getAttribute(element, "name");
+  return name?.toLowerCase() === "viewport";
+}
+
+/**
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {CustomValidationResult}
+ */
+export function validateMetaViewport(element, adapter) {
+  /** @type {string[]} */
+  const warnings = [];
+  /** @type {any} */
+  let payload = null;
+
+  const siblings = adapter.getSiblings(element);
+  const hasDuplicateViewport = siblings.some((sibling) => {
+    if (adapter.getTagName(sibling) !== "meta") return false;
+    const name = adapter.getAttribute(sibling, "name");
+    return name?.toLowerCase() === "viewport";
+  });
+
+  if (hasDuplicateViewport) {
+    const parent = adapter.getParent(element);
+    if (parent) {
+      const viewportElements = adapter.getChildren(parent).filter((/** @type {any} */ child) => {
+        if (adapter.getTagName(child) !== "meta") return false;
+        const name = adapter.getAttribute(child, "name");
+        return name?.toLowerCase() === "viewport";
+      });
+      const firstMetaViewport = viewportElements.find((/** @type {any} */ el) => el !== element);
+      if (firstMetaViewport) {
+        payload = { firstMetaViewport };
+        warnings.push(
+          "Another meta viewport element has already been declared. Having multiple viewport settings can lead to unexpected behavior.",
+        );
+        return { ruleId: "valid-meta-viewport", warnings, payload };
+      }
+    }
+  }
+
+  const content = adapter.getAttribute(element, "content")?.toLowerCase();
+  if (!content) {
+    warnings.push("Invalid viewport. The content attribute must be set.");
+    return { ruleId: "valid-meta-viewport", warnings, payload };
+  }
+
+  /** @type {Record<string, string>} */
+  const directives = Object.fromEntries(
+    content.split(",").map((directive) => {
+      const [key, value] = directive.split("=");
+      return [key?.trim(), value?.trim()];
+    }),
+  );
+
+  if ("width" in directives) {
+    const width = directives["width"];
+    if (Number(width) < 1 || Number(width) > 10000) {
+      warnings.push(`Invalid width "${width}". Numeric values must be between 1 and 10000.`);
+    } else if (width !== "device-width") {
+      warnings.push(`Invalid width "${width}".`);
+    }
+  }
+
+  if ("height" in directives) {
+    const height = directives["height"];
+    if (Number(height) < 1 || Number(height) > 10000) {
+      warnings.push(`Invalid height "${height}". Numeric values must be between 1 and 10000.`);
+    } else if (height !== "device-height") {
+      warnings.push(`Invalid height "${height}".`);
+    }
+  }
+
+  if ("initial-scale" in directives) {
+    const initialScale = Number(directives["initial-scale"]);
+    if (isNaN(initialScale)) {
+      warnings.push(`Invalid initial zoom level "${directives["initial-scale"]}". Values must be numeric.`);
+    }
+    if (initialScale < 0.1 || initialScale > 10) {
+      warnings.push(`Invalid initial zoom level "${initialScale}". Values must be between 0.1 and 10.`);
+    }
+  }
+
+  if ("minimum-scale" in directives) {
+    const minimumScale = Number(directives["minimum-scale"]);
+    if (isNaN(minimumScale)) {
+      warnings.push(`Invalid minimum zoom level "${directives["minimum-scale"]}". Values must be numeric.`);
+    }
+    if (minimumScale < 0.1 || minimumScale > 10) {
+      warnings.push(`Invalid minimum zoom level "${minimumScale}". Values must be between 0.1 and 10.`);
+    }
+  }
+
+  if ("maximum-scale" in directives) {
+    const maxScale = Number(directives["maximum-scale"]);
+    if (isNaN(maxScale)) {
+      warnings.push(`Invalid maximum zoom level "${directives["maximum-scale"]}". Values must be numeric.`);
+    }
+    if (maxScale < 0.1 || maxScale > 10) {
+      warnings.push(`Invalid maximum zoom level "${maxScale}". Values must be between 0.1 and 10.`);
+    }
+    if (maxScale < 2) {
+      warnings.push(
+        `Disabling zoom levels under 2x can cause accessibility issues. Found "maximum-scale=${directives["maximum-scale"]}".`,
+      );
+    }
+  }
+
+  if ("user-scalable" in directives) {
+    const userScalable = directives["user-scalable"];
+    if (userScalable === "no" || userScalable === "0") {
+      warnings.push(
+        `Disabling zooming can cause accessibility issues to users with visual impairments. Found "user-scalable=${userScalable}".`,
+      );
+    }
+    if (!["0", "1", "yes", "no"].includes(userScalable)) {
+      warnings.push(`Unsupported value "${userScalable}" found.`);
+    }
+  }
+
+  if ("interactive-widget" in directives) {
+    const interactiveWidget = directives["interactive-widget"];
+    const validValues = ["resizes-visual", "resizes-content", "overlays-content"];
+    if (!validValues.includes(interactiveWidget)) {
+      warnings.push(`Unsupported value "${interactiveWidget}" found.`);
+    }
+  }
+
+  if ("viewport-fit" in directives) {
+    const viewportFit = directives["viewport-fit"];
+    const validValues = ["auto", "contain", "cover"];
+    if (!validValues.includes(viewportFit)) {
+      warnings.push(`Unsupported value "${viewportFit}" found. Should be one of: ${validValues.join(", ")}.`);
+    }
+  }
+
+  if ("shrink-to-fit" in directives) {
+    warnings.push(
+      "The shrink-to-fit directive has been obsolete since iOS 9.2.\n  See https://www.scottohara.me/blog/2018/12/11/shrink-to-fit.html",
+    );
+  }
+
+  const validDirectives = new Set([
+    "width",
+    "height",
+    "initial-scale",
+    "minimum-scale",
+    "maximum-scale",
+    "user-scalable",
+    "interactive-widget",
+  ]);
+
+  Object.keys(directives)
+    .filter((directive) => {
+      if (validDirectives.has(directive)) {
+        return false;
+      }
+      if (directive === "shrink-to-fit") {
+        return false;
+      }
+      if (directive === "viewport-fit") {
+        return false;
+      }
+      return true;
+    })
+    .forEach((directive) => {
+      warnings.push(`Invalid viewport directive "${directive}".`);
+    });
+
+  return { ruleId: "valid-meta-viewport", warnings, payload };
+}

package/node_modules/@rviscomi/capo.js/src/web/capo.js

@@ -1,25 +1,25 @@
-import { analyzeHead } from "@rviscomi/capo.js";
-import { BrowserAdapter } from "@rviscomi/capo.js/adapters/browser";
-import { IO } from "@rviscomi/capo.js/lib/io";
-import { Options } from "@rviscomi/capo.js/lib/options";
-
+import { analyzeHead } from "../index.js";
+import { BrowserAdapter } from "../adapters/browser.js";
+import { IO } from "../lib/io.js";
+import { Options } from "../lib/options.js";
 
 const FORCED_OPTIONS = {
-  preferredAssessmentMode: Options.AssessmentMode.DYNAMIC
+  preferredAssessmentMode: Options.AssessmentMode.DYNAMIC,
 };
 
 /**
  * Interface for the capo.js web client.
- * 
+ *
  * For configuration options see:
  * https://rviscomi.github.io/capo.js/user/config/
- * 
+ *
  * @param {string} input HTML string
  * @param {any} output Mock console implementation
- * @param {import("@rviscomi/capo.js/lib/options").OptionsInit} [userOptions={}] Capo options
+ * @param {import("../lib/options.js").OptionsInit & { pageOrigin?: string | null }} [userOptions={}] Capo options
  */
-export function run(input, output, userOptions={}) {
-  userOptions = Object.assign(userOptions, FORCED_OPTIONS);
+export function run(input, output, userOptions = {}) {
+  const pageOrigin = userOptions.pageOrigin || null;
+  userOptions = Object.assign({}, userOptions, FORCED_OPTIONS);
 
   const options = new Options(userOptions);
   const io = new IO(null, options, output);
@@ -27,7 +27,7 @@ export function run(input, output, userOptions={}) {
 
   const headElement = io.getHead();
   const adapter = new BrowserAdapter();
-  const result = analyzeHead(headElement, adapter);
+  const result = analyzeHead(headElement, adapter, { pageOrigin });
 
   io.logAnalysis(result);
 }

package/node_modules/@rviscomi/capo.js/src/worker/worker.js

@@ -0,0 +1,180 @@
+/**
+ * Cloudflare worker script for Capo.js:
+ *
+ * - Proxies requests ONLY from allowed origins using CORS.
+ * - Accepts a POST request to `/auth` with `{ code, redirect_uri }` to exchange GitHub OAuth codes for access tokens.
+ * - Accepts a `url` GET parameter to proxy HTML text responses from target sites.
+ */
+
+const ALLOWED_ORIGINS = [
+  "http://localhost:3000",
+  "http://localhost:4321",
+  "https://rviscomi.github.io",
+  "https://dash.cloudflare.com",
+];
+
+class CorsResponse extends Response {
+  /**
+   * @param {string} origin
+   * @param {BodyInit | null} body
+   * @param {ResponseInit} options
+   */
+  constructor(origin, body, options = {}) {
+    /** @type {Record<string, string>} */
+    let cors = { Vary: "Origin" };
+    const isAllowed = ALLOWED_ORIGINS.includes(origin);
+    if (isAllowed) {
+      cors["Access-Control-Allow-Origin"] = origin;
+    }
+
+    options.headers = options.headers || {};
+    Object.assign(options.headers, cors);
+    super(body, options);
+  }
+}
+
+export default {
+  /**
+   * @param {Request} request
+   * @param {any} env
+   * @returns {Promise<Response>}
+   */
+  async fetch(request, env) {
+    if (request.method === "OPTIONS") {
+      return handleOptions(request);
+    }
+
+    return handleRequest(request, env);
+  },
+};
+
+/**
+ * @param {Request} request
+ * @param {any} env
+ * @returns {Promise<Response>}
+ */
+async function handleRequest(request, env) {
+  const url = new URL(request.url);
+  const origin = request.headers.get("origin") || "";
+  const pathname = url.pathname.replace(/\/$/, ""); // Normalize trailing slashes
+
+  // Handle OAuth code exchange (/auth)
+  if (pathname === "/auth") {
+    if (request.method !== "POST") {
+      return new CorsResponse(origin, JSON.stringify({ error: "Method Not Allowed" }), {
+        status: 405,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    try {
+      const { code, redirect_uri, client_id } = await request.json();
+      if (!code) {
+        return new CorsResponse(origin, JSON.stringify({ error: "Missing code" }), {
+          status: 400,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+
+      let targetClientId = client_id;
+      let targetClientSecret;
+
+      if (client_id === env.DEV_GITHUB_CLIENT_ID) {
+        targetClientId = env.DEV_GITHUB_CLIENT_ID;
+        targetClientSecret = env.DEV_GITHUB_CLIENT_SECRET;
+      } else if (client_id === env.PROD_GITHUB_CLIENT_ID) {
+        targetClientId = env.PROD_GITHUB_CLIENT_ID;
+        targetClientSecret = env.PROD_GITHUB_CLIENT_SECRET;
+      } else {
+        targetClientId = env.GITHUB_CLIENT_ID || client_id;
+        targetClientSecret = env.GITHUB_CLIENT_SECRET || env.DEV_GITHUB_CLIENT_SECRET || env.PROD_GITHUB_CLIENT_SECRET;
+      }
+
+      const tokenResponse = await fetch("https://github.com/login/oauth/access_token", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+        },
+        body: JSON.stringify({
+          client_id: targetClientId,
+          client_secret: targetClientSecret,
+          code: code,
+          redirect_uri: redirect_uri,
+        }),
+      });
+
+      const data = await tokenResponse.json();
+      return new CorsResponse(origin, JSON.stringify(data), {
+        status: tokenResponse.status,
+        headers: { "Content-Type": "application/json" },
+      });
+    } catch (err) {
+      return new CorsResponse(origin, JSON.stringify({ error: err instanceof Error ? err.message : String(err) }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+  }
+
+  // Original proxy handler (?url=...)
+  const target = url.searchParams.get("url");
+  if (!target) {
+    return new CorsResponse(origin, "Missing `url` parameter", { status: 400 });
+  }
+
+  let response;
+  try {
+    response = await fetch(target);
+  } catch (e) {
+    return new CorsResponse(origin, "Fetch error", { status: 502 });
+  }
+
+  if (response.status === 530) {
+    return new CorsResponse(origin, "Page does not exist", { status: 404 });
+  }
+  if (!response.ok) {
+    return new CorsResponse(origin, "Bad response from target", { status: 502 });
+  }
+
+  const body = await response.text();
+
+  return new CorsResponse(origin, body, {
+    headers: {
+      "Content-Type": "text/plain;charset=utf-8",
+    },
+  });
+}
+
+/**
+ * @param {Request} request
+ * @returns {Promise<Response>}
+ */
+async function handleOptions(request) {
+  const origin = request.headers.get("origin") || "";
+  const isAllowed = ALLOWED_ORIGINS.includes(origin);
+  const corsHeaders = {
+    "Access-Control-Allow-Origin": isAllowed ? origin : "",
+    "Access-Control-Allow-Methods": "GET,POST,OPTIONS",
+    "Access-Control-Max-Age": "86400",
+  };
+
+  if (
+    request.headers.get("Origin") !== null &&
+    request.headers.get("Access-Control-Request-Method") !== null &&
+    request.headers.get("Access-Control-Request-Headers") !== null
+  ) {
+    return new Response(null, {
+      headers: {
+        ...corsHeaders,
+        "Access-Control-Allow-Headers": request.headers.get("Access-Control-Request-Headers") || "",
+      },
+    });
+  } else {
+    return new Response(null, {
+      headers: {
+        Allow: corsHeaders["Access-Control-Allow-Methods"],
+      },
+    });
+  }
+}

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslint-recommended-raw.d.ts

@@ -3,8 +3,8 @@
  * - disables rules from eslint:recommended which are already handled by TypeScript.
  * - enables rules that make sense due to TS's typechecking / transpilation.
  */
-declare const config: (style: "glob" | "minimatch") => {
+declare const config: (style: 'glob' | 'minimatch') => {
     files: string[];
-    rules: Record<string, "error" | "off" | "warn">;
+    rules: Record<string, 'error' | 'off' | 'warn'>;
 };
 export = config;

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslint-recommended-raw.js

@@ -44,3 +44,4 @@ const config = (style) => ({
     },
 });
 module.exports = config;
+//# sourceMappingURL=eslint-recommended-raw.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/all.js

@@ -159,3 +159,4 @@ module.exports = {
         '@typescript-eslint/use-unknown-in-catch-callback-variable': 'error',
     },
 };
+//# sourceMappingURL=all.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/base.js

@@ -4,3 +4,4 @@ module.exports = {
     parserOptions: { sourceType: 'module' },
     plugins: ['@typescript-eslint'],
 };
+//# sourceMappingURL=base.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/disable-type-checked.js

@@ -71,3 +71,4 @@ module.exports = {
         '@typescript-eslint/use-unknown-in-catch-callback-variable': 'off',
     },
 };
+//# sourceMappingURL=disable-type-checked.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/eslint-recommended.d.ts

@@ -6,7 +6,7 @@
 declare const _default: {
     overrides: {
         files: string[];
-        rules: Record<string, "error" | "off" | "warn">;
+        rules: Record<string, 'error' | 'off' | 'warn'>;
     }[];
 };
 export = _default;

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/eslint-recommended.js

@@ -11,3 +11,4 @@ const eslint_recommended_raw_1 = __importDefault(require("../eslint-recommended-
 module.exports = {
     overrides: [(0, eslint_recommended_raw_1.default)('glob')],
 };
+//# sourceMappingURL=eslint-recommended.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended-type-checked-only.js

@@ -37,3 +37,4 @@ module.exports = {
         '@typescript-eslint/unbound-method': 'error',
     },
 };
+//# sourceMappingURL=recommended-type-checked-only.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended-type-checked.js

@@ -60,3 +60,4 @@ module.exports = {
         '@typescript-eslint/unbound-method': 'error',
     },
 };
+//# sourceMappingURL=recommended-type-checked.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended.js

@@ -33,3 +33,4 @@ module.exports = {
         '@typescript-eslint/triple-slash-reference': 'error',
     },
 };
+//# sourceMappingURL=recommended.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict-type-checked-only.js

@@ -77,3 +77,4 @@ module.exports = {
         '@typescript-eslint/use-unknown-in-catch-callback-variable': 'error',
     },
 };
+//# sourceMappingURL=strict-type-checked-only.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict-type-checked.js

@@ -112,3 +112,4 @@ module.exports = {
         '@typescript-eslint/use-unknown-in-catch-callback-variable': 'error',
     },
 };
+//# sourceMappingURL=strict-type-checked.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict.js

@@ -45,3 +45,4 @@ module.exports = {
         '@typescript-eslint/unified-signatures': 'error',
     },
 };
+//# sourceMappingURL=strict.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic-type-checked-only.js

@@ -19,3 +19,4 @@ module.exports = {
         '@typescript-eslint/prefer-string-starts-ends-with': 'error',
     },
 };
+//# sourceMappingURL=stylistic-type-checked-only.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic-type-checked.js

@@ -33,3 +33,4 @@ module.exports = {
         '@typescript-eslint/prefer-string-starts-ends-with': 'error',
     },
 };
+//# sourceMappingURL=stylistic-type-checked.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic.js

@@ -24,3 +24,4 @@ module.exports = {
         '@typescript-eslint/prefer-function-type': 'error',
     },
 };
+//# sourceMappingURL=stylistic.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/all.d.ts

@@ -1,7 +1,7 @@
 import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+export default _default;
 /**
  * Enables each the rules provided as a part of typescript-eslint. Note that many rules are not applicable in all codebases, or are meant to be configured.
  * @see {@link https://typescript-eslint.io/users/configs#all}
  */
-declare const _default: (plugin: FlatConfig.Plugin, parser: FlatConfig.Parser) => FlatConfig.ConfigArray;
-export default _default;
+declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.ConfigArray;

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/all.js

@@ -173,3 +173,4 @@ exports.default = (plugin, parser) => [
         },
     },
 ];
+//# sourceMappingURL=all.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/base.d.ts

@@ -1,8 +1,8 @@
 import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+export default _default;
 /**
  * A minimal ruleset that sets only the required parser and plugin options needed to run typescript-eslint.
  * We don't recommend using this directly; instead, extend from an earlier recommended rule.
  * @see {@link https://typescript-eslint.io/users/configs#base}
  */
-declare const _default: (plugin: FlatConfig.Plugin, parser: FlatConfig.Parser) => FlatConfig.Config;
-export default _default;
+declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.Config;

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/base.js

@@ -15,3 +15,4 @@ exports.default = (plugin, parser) => ({
         '@typescript-eslint': plugin,
     },
 });
+//# sourceMappingURL=base.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/disable-type-checked.d.ts

@@ -1,7 +1,7 @@
 import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+export default _default;
 /**
  * A utility ruleset that will disable type-aware linting and all type-aware rules available in our project.
  * @see {@link https://typescript-eslint.io/users/configs#disable-type-checked}
  */
-declare const _default: (_plugin: FlatConfig.Plugin, _parser: FlatConfig.Parser) => FlatConfig.Config;
-export default _default;
+declare function _default(_plugin: FlatConfig.Plugin, _parser: FlatConfig.Parser): FlatConfig.Config;

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/disable-type-checked.js

@@ -79,3 +79,4 @@ exports.default = (_plugin, _parser) => ({
         parserOptions: { program: null, project: false, projectService: false },
     },
 });
+//# sourceMappingURL=disable-type-checked.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/eslint-recommended.d.ts

@@ -1,9 +1,9 @@
 import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+export default _default;
 /**
  * This is a compatibility ruleset that:
  * - disables rules from eslint:recommended which are already handled by TypeScript.
  * - enables rules that make sense due to TS's typechecking / transpilation.
  * @see {@link https://typescript-eslint.io/users/configs/#eslint-recommended}
  */
-declare const _default: (_plugin: FlatConfig.Plugin, _parser: FlatConfig.Parser) => FlatConfig.Config;
-export default _default;
+declare function _default(_plugin: FlatConfig.Plugin, _parser: FlatConfig.Parser): FlatConfig.Config;

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/eslint-recommended.js

@@ -14,3 +14,4 @@ exports.default = (_plugin, _parser) => ({
     ...(0, eslint_recommended_raw_1.default)('minimatch'),
     name: 'typescript-eslint/eslint-recommended',
 });
+//# sourceMappingURL=eslint-recommended.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended-type-checked-only.d.ts

@@ -1,7 +1,7 @@
 import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+export default _default;
 /**
  * A version of `recommended` that only contains type-checked rules and disables of any corresponding core ESLint rules.
  * @see {@link https://typescript-eslint.io/users/configs#recommended-type-checked-only}
  */
-declare const _default: (plugin: FlatConfig.Plugin, parser: FlatConfig.Parser) => FlatConfig.ConfigArray;
-export default _default;
+declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.ConfigArray;

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended-type-checked-only.js

@@ -51,3 +51,4 @@ exports.default = (plugin, parser) => [
         },
     },
 ];
+//# sourceMappingURL=recommended-type-checked-only.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended-type-checked.d.ts

@@ -1,7 +1,7 @@
 import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+export default _default;
 /**
  * Contains all of `recommended` along with additional recommended rules that require type information.
  * @see {@link https://typescript-eslint.io/users/configs#recommended-type-checked}
  */
-declare const _default: (plugin: FlatConfig.Plugin, parser: FlatConfig.Parser) => FlatConfig.ConfigArray;
-export default _default;
+declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.ConfigArray;

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended-type-checked.js

@@ -74,3 +74,4 @@ exports.default = (plugin, parser) => [
         },
     },
 ];
+//# sourceMappingURL=recommended-type-checked.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended.d.ts

@@ -1,7 +1,7 @@
 import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+export default _default;
 /**
  * Recommended rules for code correctness that you can drop in without additional configuration.
  * @see {@link https://typescript-eslint.io/users/configs#recommended}
  */
-declare const _default: (plugin: FlatConfig.Plugin, parser: FlatConfig.Parser) => FlatConfig.ConfigArray;
-export default _default;
+declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.ConfigArray;

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended.js

@@ -47,3 +47,4 @@ exports.default = (plugin, parser) => [
         },
     },
 ];
+//# sourceMappingURL=recommended.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict-type-checked-only.d.ts

@@ -1,7 +1,7 @@
 import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+export default _default;
 /**
  * A version of `strict` that only contains type-checked rules and disables of any corresponding core ESLint rules.
  * @see {@link https://typescript-eslint.io/users/configs#strict-type-checked-only}
  */
-declare const _default: (plugin: FlatConfig.Plugin, parser: FlatConfig.Parser) => FlatConfig.ConfigArray;
-export default _default;
+declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.ConfigArray;