@askviraj/linter 1.1.2 → 1.1.3

package/node_modules/postcss/lib/stringifier.js

@@ -6,6 +6,10 @@
 const STYLE_TAG = /(<)(\/?style\b)/gi
 const COMMENT_OPEN = /(<)(!--)/g
 
+// Characters that end an at-rule name, mirroring RE_AT_END in the tokenizer.
+// Params starting with anything else need a space to stay separate tokens.
+const AT_NAME_END = /[\t\n\f\r "#'()/;[\\\]{}]/
+
 function escapeHTMLInCSS(str) {
   if (typeof str !== 'string') return str
   if (!str.includes('<')) return str
@@ -31,27 +35,89 @@ function capitalize(str) {
   return str[0].toUpperCase() + str.slice(1)
 }
 
+function atruleStart(str, node) {
+  let name = '@' + node.name
+  let params = node.params ? str.rawValue(node, 'params') : ''
+  let afterName = node.raws.afterName
+
+  if (typeof afterName === 'undefined') {
+    afterName = params ? ' ' : ''
+  } else if (afterName === '' && params && !AT_NAME_END.test(params[0])) {
+    afterName = ' '
+  }
+
+  return name + afterName + params
+}
+
+function pushBody(str, stack, node) {
+  let nodes = node.nodes
+  let last = nodes.length - 1
+  while (last > 0) {
+    if (nodes[last].type !== 'comment') break
+    last -= 1
+  }
+
+  let semicolon = str.raw(node, 'semicolon')
+  let isDocument = node.type === 'document'
+  for (let i = nodes.length - 1; i >= 0; i--) {
+    let child = nodes[i]
+    let childSemicolon = last !== i || semicolon
+    // A childless at-rule or a custom property declaration that still has
+    // following siblings must be terminated. Without the semicolon those
+    // trailing comments are folded into the at-rule's prelude or the custom
+    // property's value and disappear when the output is re-parsed.
+    if (
+      !childSemicolon &&
+      i < nodes.length - 1 &&
+      ((child.type === 'atrule' && !child.nodes) ||
+        (child.type === 'decl' && child.prop.startsWith('--')))
+    ) {
+      childSemicolon = true
+    }
+    stack.push({
+      document: isDocument,
+      node: child,
+      semicolon: childSemicolon
+    })
+  }
+}
+
+function pushBlock(str, stack, node, start) {
+  let between = str.raw(node, 'between', 'beforeOpen')
+  str.builder(escapeHTMLInCSS(start + between) + '{', node, 'start')
+
+  let hasNodes = node.nodes && node.nodes.length
+  let close = () => {
+    let after = hasNodes
+      ? str.raw(node, 'after')
+      : str.raw(node, 'after', 'emptyBody')
+    if (after) str.builder(escapeHTMLInCSS(after))
+    str.builder('}', node, 'end')
+    if (node.type === 'rule' && node.raws.ownSemicolon) {
+      str.builder(escapeHTMLInCSS(node.raws.ownSemicolon), node, 'end')
+    }
+  }
+
+  if (hasNodes) {
+    stack.push(close)
+    pushBody(str, stack, node)
+  } else {
+    close()
+  }
+}
+
 class Stringifier {
   constructor(builder) {
     this.builder = builder
   }
 
   atrule(node, semicolon) {
-    let raws = node.raws
-    let name = '@' + node.name
-    let params = node.params ? this.rawValue(node, 'params') : ''
-
-    if (typeof raws.afterName !== 'undefined') {
-      name += raws.afterName
-    } else if (params) {
-      name += ' '
-    }
-
+    let start = atruleStart(this, node)
     if (node.nodes) {
-      this.block(node, name + params)
+      this.block(node, start)
     } else {
-      let end = (raws.between || '') + (semicolon ? ';' : '')
-      this.builder(escapeHTMLInCSS(name + params + end), node)
+      let end = (node.raws.between || '') + (semicolon ? ';' : '')
+      this.builder(escapeHTMLInCSS(start + end), node)
     }
   }
 
@@ -101,20 +167,38 @@ class Stringifier {
   }
 
   body(node) {
-    let nodes = node.nodes
-    let last = nodes.length - 1
-    while (last > 0) {
-      if (nodes[last].type !== 'comment') break
-      last -= 1
-    }
+    // Rules and at-rules are expanded into an explicit stack instead of
+    // recursive `stringify()` calls to survive deeply nested trees.
+    // If a subclass changes the traversal methods, its children go
+    // through `stringify()` to keep the override in charge.
+    let proto = Stringifier.prototype
+    let expandable = ['atrule', 'block', 'body', 'rule', 'stringify'].every(
+      method => this[method] === proto[method]
+    )
+
+    let stack = []
+    pushBody(this, stack, node)
+
+    while (stack.length > 0) {
+      let entry = stack.pop()
+      if (typeof entry === 'function') {
+        entry()
+        continue
+      }
 
-    let semicolon = this.raw(node, 'semicolon')
-    let isDocument = node.type === 'document'
-    for (let i = 0; i < nodes.length; i++) {
-      let child = nodes[i]
+      let child = entry.node
       let before = this.raw(child, 'before')
-      if (before) this.builder(isDocument ? before : escapeHTMLInCSS(before))
-      this.stringify(child, last !== i || semicolon)
+      if (before) {
+        this.builder(entry.document ? before : escapeHTMLInCSS(before))
+      }
+
+      if (expandable && child.type === 'rule') {
+        pushBlock(this, stack, child, this.rawValue(child, 'selector'))
+      } else if (expandable && child.type === 'atrule' && child.nodes) {
+        pushBlock(this, stack, child, atruleStart(this, child))
+      } else {
+        this.stringify(child, entry.semicolon)
+      }
     }
   }
 
@@ -340,6 +424,9 @@ class Stringifier {
   }
 
   root(node) {
+    if (node.source && node.source.input.hasBOM) {
+      this.builder('\uFEFF', node, 'start')
+    }
     this.body(node)
     if (node.raws.after) {
       let after = node.raws.after

package/node_modules/postcss/lib/warning.js

@@ -1,11 +1,21 @@
 'use strict'
 
+let Container = require('./container')
+let { my } = require('./symbols')
+
 class Warning {
   constructor(text, opts = {}) {
     this.type = 'warning'
     this.text = text
 
     if (opts.node && opts.node.source) {
+      if (!opts.node[my]) {
+        // The node comes from another PostCSS copy in node_modules, so it does
+        // not have this copy’s methods. Container#normalize() rebuilds such
+        // nodes on insert, but a node passed straight to Result#warn() never
+        // goes through it.
+        Container.rebuild(opts.node)
+      }
       let range = opts.node.rangeBy(opts)
       this.line = range.start.line
       this.column = range.start.column

package/node_modules/postcss/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss",
-  "version": "8.5.16",
+  "version": "8.5.25",
   "description": "Tool for transforming styles with JS plugins",
   "keywords": [
     "css",
@@ -78,7 +78,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "nanoid": "^3.3.12",
+    "nanoid": "^3.3.16",
     "picocolors": "^1.1.1",
     "source-map-js": "^1.2.1"
   },

package/node_modules/typescript-eslint/dist/index.js

@@ -1,9 +1,56 @@
 "use strict";
+/* eslint-disable import/first -- intentionally executing code before rest of the require()s. This will not work with ESM. */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.config = exports.configs = exports.plugin = exports.parser = void 0;
+const ts = __importStar(require("typescript"));
+const [versionMajor, _versionMinor] = ts.versionMajorMinor
+    .split('.')
+    .map(Number);
+if (versionMajor >= 7) {
+    // eslint-disable-next-line no-console
+    console.error([
+        'typescript-eslint does not support TS 7.0.',
+        'Please see https://devblogs.microsoft.com/typescript/announcing-typescript-7-0/#running-side-by-side-with-typescript-6.0 to run typescript-eslint using the TS 6 API.',
+        "See also https://github.com/typescript-eslint/typescript-eslint/issues/10940 for tracking typescript-eslint's support for TS >=7.1",
+    ].join('\n'));
+    throw new Error('typescript-eslint does not support TS 7.0.');
+}
 const eslint_plugin_1 = __importDefault(require("@typescript-eslint/eslint-plugin"));
 const raw_plugin_1 = __importDefault(require("@typescript-eslint/eslint-plugin/use-at-your-own-risk/raw-plugin"));
 const typescript_estree_1 = require("@typescript-eslint/typescript-estree");

package/node_modules/typescript-eslint/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typescript-eslint",
-  "version": "8.62.1",
+  "version": "8.65.0",
   "description": "Tooling which enables you to use TypeScript with ESLint",
   "files": [
     "dist",
@@ -40,10 +40,10 @@
     "eslint-plugin"
   ],
   "dependencies": {
-    "@typescript-eslint/eslint-plugin": "8.62.1",
-    "@typescript-eslint/parser": "8.62.1",
-    "@typescript-eslint/typescript-estree": "8.62.1",
-    "@typescript-eslint/utils": "8.62.1"
+    "@typescript-eslint/eslint-plugin": "8.65.0",
+    "@typescript-eslint/parser": "8.65.0",
+    "@typescript-eslint/utils": "8.65.0",
+    "@typescript-eslint/typescript-estree": "8.65.0"
   },
   "peerDependencies": {
     "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
@@ -87,6 +87,13 @@
           "^build",
           "typecheck"
         ]
+      },
+      "attw-check": {
+        "cache": false,
+        "options": {
+          "cwd": "{projectRoot}"
+        },
+        "command": "pnpm pack --out attw-check.tgz && attw attw-check.tgz --profile node16 --ignore-rules cjs-only-exports-default"
       }
     }
   },
@@ -97,6 +104,7 @@
     "lint": "pnpm -w exec nx lint",
     "test": "pnpm -w exec nx test",
     "typecheck": "pnpm -w exec nx typecheck",
-    "typecheck:tsgo": "pnpm -w exec nx typecheck:tsgo"
+    "typecheck:tsgo": "pnpm -w exec nx typecheck:tsgo",
+    "attw-check": "pnpm -w exec nx attw-check"
   }
 }

package/node_modules/yaml-eslint-parser/lib/chunk-CfYAbeIz.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/node_modules/yaml-eslint-parser/lib/index.d.mts

@@ -205,8 +205,8 @@ declare class ParseError extends SyntaxError {
 declare namespace meta_d_exports {
   export { name, version };
 }
-declare const name: "yaml-eslint-parser";
-declare const version: "2.0.0";
+declare const name: string;
+declare const version: string;
 //#endregion
 //#region src/index.d.ts
 declare const VisitorKeys: SourceCode.VisitorKeys;