Website Structure

Frontend-Learner/node_modules/postcss-discard-comments/LICENSE-MIT

@@ -0,0 +1,22 @@
+Copyright (c) Ben Briggs <beneb.info@gmail.com> (http://beneb.info)
+
+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.

Frontend-Learner/node_modules/postcss-discard-comments/README.md

@@ -0,0 +1,114 @@
+# [postcss][postcss]-discard-comments
+
+> Discard comments in your CSS files with PostCSS.
+
+
+## Install
+
+With [npm](https://npmjs.org/package/postcss-discard-comments) do:
+
+```
+npm install postcss-discard-comments --save
+```
+
+
+## Example
+
+### Input
+
+```css
+h1/* heading */{
+    margin: 0 auto
+}
+```
+
+### Output
+
+```css
+h1 {
+    margin: 0 auto
+}
+```
+
+This module discards comments from your CSS files; by default, it will remove
+all regular comments (`/* comment */`) and preserve comments marked as important
+(`/*! important */`).
+
+Note that this module does not handle source map comments because they are not
+available to it; PostCSS handles this internally, so if they are removed then
+you will have to [configure source maps in PostCSS][maps].
+
+[maps]: https://github.com/postcss/postcss/blob/master/docs/source-maps.md
+
+
+## API
+
+### comments([options])
+
+#### options
+
+##### remove(function)
+
+Type: `function`
+Return: `boolean`
+Variable: `comment` contains a comment without `/**/`
+
+For each comment, return true to remove, or false to keep the comment.
+
+```js
+function(comment) {}
+```
+
+```js
+var css = '/* headings *//*@ h1 */h1{margin:0 auto}/*@ h2 */h2{color:red}';
+console.log(postcss(comments({
+    remove: function(comment) { return comment[0] == "@"; }
+})).process(css).css);
+//=> /* headings */h1{margin:0 auto}h2{color:red}
+```
+**NOTE:** If you use the `remove` function other options will not be available.
+
+##### removeAll
+
+Type: `boolean`
+Default: `false`
+
+Remove all comments marked as important.
+
+```js
+var css = '/*! heading */h1{margin:0 auto}/*! heading 2 */h2{color:red}';
+console.log(postcss(comments({removeAll: true})).process(css).css);
+//=> h1{margin:0 auto}h2{color:red}
+```
+
+##### removeAllButFirst
+
+Type: `boolean`
+Default: `false`
+
+Remove all comments marked as important, but the first one.
+
+```js
+var css = '/*! heading */h1{margin:0 auto}/*! heading 2 */h2{color:red}';
+console.log(postcss(comments({removeAllButFirst: true})).process(css).css);
+//=> /*! heading */h1{margin:0 auto}h2{color:red}
+```
+
+
+## Usage
+
+See the [PostCSS documentation](https://github.com/postcss/postcss#usage) for
+examples for your environment.
+
+
+## Contributors
+
+See [CONTRIBUTORS.md](https://github.com/cssnano/cssnano/blob/master/CONTRIBUTORS.md).
+
+
+## License
+
+MIT © [Ben Briggs](http://beneb.info)
+
+
+[postcss]: https://github.com/postcss/postcss

Frontend-Learner/node_modules/postcss-discard-comments/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "postcss-discard-comments",
+  "version": "7.0.5",
+  "description": "Discard comments in your CSS files with PostCSS.",
+  "main": "src/index.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "src",
+    "LICENSE-MIT",
+    "types"
+  ],
+  "keywords": [
+    "css",
+    "comments",
+    "postcss",
+    "postcss-plugin"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/cssnano/cssnano",
+  "author": {
+    "name": "Ben Briggs",
+    "email": "beneb.info@gmail.com",
+    "url": "http://beneb.info"
+  },
+  "repository": "cssnano/cssnano",
+  "dependencies": {
+    "postcss-selector-parser": "^7.1.0"
+  },
+  "bugs": {
+    "url": "https://github.com/cssnano/cssnano/issues"
+  },
+  "engines": {
+    "node": "^18.12.0 || ^20.9.0 || >=22.0"
+  },
+  "devDependencies": {
+    "postcss": "^8.5.6",
+    "postcss-scss": "^4.0.9",
+    "postcss-simple-vars": "^7.0.1"
+  },
+  "peerDependencies": {
+    "postcss": "^8.4.32"
+  }
+}

Frontend-Learner/node_modules/postcss-discard-comments/src/index.js

@@ -0,0 +1,239 @@
+'use strict';
+const CommentRemover = require('./lib/commentRemover');
+const commentParser = require('./lib/commentParser');
+const selectorParser = require('postcss-selector-parser');
+
+/** @typedef {object} Options
+ *  @property {boolean=} removeAll
+ *  @property {boolean=} removeAllButFirst
+ *  @property {(s: string) => boolean=} remove
+ */
+/**
+ * @type {import('postcss').PluginCreator<Options>}
+ * @param {Options} opts
+ * @return {import('postcss').Plugin}
+ */
+function pluginCreator(opts = {}) {
+  const remover = new CommentRemover(opts);
+  const matcherCache = new Map();
+  const parserCache = new Map();
+  const replacerCache = new Map();
+
+  /**
+   * @param {string} source
+   * @return {[number, number, number][]}
+   */
+  function getTokens(source) {
+    if (parserCache.has(source)) {
+      return parserCache.get(source);
+    }
+
+    const tokens = commentParser(source);
+
+    parserCache.set(source, tokens);
+
+    return tokens;
+  }
+
+  /**
+   * @param {string} source
+   * @return {[number, number, number][]}
+   */
+  function matchesComments(source) {
+    if (matcherCache.has(source)) {
+      return matcherCache.get(source);
+    }
+
+    const result = getTokens(source).filter(([type]) => type);
+
+    matcherCache.set(source, result);
+
+    return result;
+  }
+
+  /**
+   * @param {string | undefined} rawSource
+   * @param {(s: string) => string[]} space
+   * @param {string=} separator
+   * @return {string}
+   */
+  function replaceComments(rawSource, space, separator = ' ') {
+    const source = rawSource || '';
+    const key = source + '@|@' + separator;
+
+    if (replacerCache.has(key)) {
+      return replacerCache.get(key);
+    }
+
+    if (source.indexOf('/*') === -1) {
+      const normalized = space(source).join(' ');
+
+      replacerCache.set(key, normalized);
+
+      return normalized;
+    }
+
+    const parts = [];
+
+    for (const [type, start, end] of getTokens(source)) {
+      if (!type) {
+        parts.push(source.slice(start, end));
+        continue;
+      }
+
+      const contents = source.slice(start, end);
+
+      if (remover.canRemove(contents)) {
+        parts.push(separator);
+        continue;
+      }
+
+      parts.push('/*' + contents + '*/');
+    }
+
+    const parsed = parts.join('');
+
+    const result = space(parsed).join(' ');
+
+    replacerCache.set(key, result);
+
+    return result;
+  }
+
+  /**
+   * @param {string | undefined} rawSource
+   * @param {(s: string) => string[]} space
+   * @return {string}
+   */
+  function replaceCommentsInSelector(rawSource, space) {
+    const source = rawSource || '';
+    const key = source + '@|@';
+
+    if (replacerCache.has(key)) {
+      return replacerCache.get(key);
+    }
+    if (source.indexOf('/*') === -1) {
+      const normalized = space(source).join(' ');
+
+      replacerCache.set(key, normalized);
+
+      return normalized;
+    }
+    const processed = selectorParser((ast) => {
+      ast.walk((node) => {
+        if (node.type === 'comment') {
+          const contents = node.value.slice(2, -2);
+          if (remover.canRemove(contents)) {
+            node.remove();
+          }
+        }
+        const rawSpaceAfter = replaceComments(node.rawSpaceAfter, space, '');
+        const rawSpaceBefore = replaceComments(node.rawSpaceBefore, space, '');
+        // If comments are not removed, the result of trim will be returned,
+        // so if we compare and there are no changes, skip it.
+        if (rawSpaceAfter !== node.rawSpaceAfter.trim()) {
+          node.rawSpaceAfter = rawSpaceAfter;
+        }
+        if (rawSpaceBefore !== node.rawSpaceBefore.trim()) {
+          node.rawSpaceBefore = rawSpaceBefore;
+        }
+      });
+    }).processSync(source);
+
+    const result = space(processed).join(' ');
+
+    replacerCache.set(key, result);
+
+    return result;
+  }
+
+  return {
+    postcssPlugin: 'postcss-discard-comments',
+
+    OnceExit(css, { list }) {
+      css.walk((node) => {
+        if (node.type === 'comment' && remover.canRemove(node.text)) {
+          node.remove();
+
+          return;
+        }
+
+        if (typeof node.raws.between === 'string') {
+          node.raws.between = replaceComments(node.raws.between, list.space);
+        }
+
+        if (node.type === 'decl') {
+          if (node.raws.value && node.raws.value.raw) {
+            if (node.raws.value.value === node.value) {
+              node.value = replaceComments(node.raws.value.raw, list.space);
+            } else {
+              node.value = replaceComments(node.value, list.space);
+            }
+
+            /** @type {null | {value: string, raw: string}} */ (
+              node.raws.value
+            ) = null;
+          }
+
+          if (node.raws.important) {
+            node.raws.important = replaceComments(
+              node.raws.important,
+              list.space
+            );
+
+            const b = matchesComments(node.raws.important);
+
+            node.raws.important = b.length ? node.raws.important : '!important';
+          } else {
+            node.value = replaceComments(node.value, list.space);
+          }
+
+          return;
+        }
+
+        if (node.type === 'rule') {
+          if (node.raws.selector && node.raws.selector.raw) {
+            node.raws.selector.raw = replaceCommentsInSelector(
+              node.raws.selector.raw,
+              list.space
+            );
+          } else if (node.selector && node.selector.includes('/*')) {
+            node.selector = replaceCommentsInSelector(
+              node.selector,
+              list.space
+            );
+          }
+
+          return;
+        }
+
+        if (node.type === 'atrule') {
+          if (node.raws.afterName) {
+            const commentsReplaced = replaceComments(
+              node.raws.afterName,
+              list.space
+            );
+
+            if (!commentsReplaced.length) {
+              node.raws.afterName = commentsReplaced + ' ';
+            } else {
+              node.raws.afterName = ' ' + commentsReplaced + ' ';
+            }
+          }
+
+          if (node.raws.params && node.raws.params.raw) {
+            node.raws.params.raw = replaceComments(
+              node.raws.params.raw,
+              list.space
+            );
+          } else if (node.params && node.params.includes('/*')) {
+            node.params = replaceComments(node.params, list.space);
+          }
+        }
+      });
+    },
+  };
+}
+
+pluginCreator.postcss = true;
+module.exports = pluginCreator;

Frontend-Learner/node_modules/postcss-discard-comments/src/lib/commentParser.js

@@ -0,0 +1,95 @@
+'use strict';
+
+// State machine states reused between parses for better perf
+const STATES = {
+  NORMAL: 0,
+  IN_SINGLE_QUOTE: 1,
+  IN_DOUBLE_QUOTE: 2,
+  IN_COMMENT: 3,
+};
+
+/**
+ * CSS Comment Parser with context awareness
+ * Properly handles comments inside strings, URLs, and escaped characters
+ *
+ * @param {string} input
+ * @return {[number, number, number][]}
+ */
+module.exports = function commentParser(input) {
+  /** @type {[number, number, number][]} */
+  const tokens = [];
+  const length = input.length;
+  let pos = 0;
+  
+  let state = STATES.NORMAL;
+  let tokenStart = 0;
+  let commentStart = 0;
+  
+  while (pos < length) {
+    const char = input[pos];
+    const nextChar = pos + 1 < length ? input[pos + 1] : '';
+    
+    switch (state) {
+      case STATES.NORMAL:
+        if (char === '/' && nextChar === '*') {
+          // Found comment start - add non-comment token if needed
+          if (pos > tokenStart) {
+            tokens.push([0, tokenStart, pos]);
+          }
+          commentStart = pos;
+          state = STATES.IN_COMMENT;
+          pos += 2; // Skip /*
+          continue;
+        } else if (char === '"') {
+          state = STATES.IN_DOUBLE_QUOTE;
+        } else if (char === "'") {
+          state = STATES.IN_SINGLE_QUOTE;
+        }
+        break;
+        
+      case STATES.IN_SINGLE_QUOTE:
+        if (char === '\\' && nextChar) {
+          // Skip escaped character
+          pos += 2;
+          continue;
+        } else if (char === "'") {
+          state = STATES.NORMAL;
+        }
+        break;
+        
+      case STATES.IN_DOUBLE_QUOTE:
+        if (char === '\\' && nextChar) {
+          // Skip escaped character
+          pos += 2;
+          continue;
+        } else if (char === '"') {
+          state = STATES.NORMAL;
+        }
+        break;
+        
+      case STATES.IN_COMMENT:
+        if (char === '*' && nextChar === '/') {
+          // Found comment end
+          tokens.push([1, commentStart + 2, pos]);
+          tokenStart = pos + 2;
+          state = STATES.NORMAL;
+          pos += 2; // Skip */
+          continue;
+        }
+        break;
+    }
+    
+    pos++;
+  }
+  
+  // Handle remaining content
+  if (state === STATES.IN_COMMENT) {
+    // Unclosed comment - treat as comment to end
+    tokens.push([1, commentStart + 2, length]);
+  } else if (tokenStart < length) {
+    // Add final non-comment token
+    tokens.push([0, tokenStart, length]);
+  }
+  
+  return tokens;
+};

Frontend-Learner/node_modules/postcss-discard-comments/src/lib/commentRemover.js

@@ -0,0 +1,32 @@
+'use strict';
+
+/** @param {import('../index.js').Options} options */
+function CommentRemover(options) {
+  this.options = options;
+}
+/**
+ * @param {string} comment
+ * @return {boolean | undefined}
+ */
+CommentRemover.prototype.canRemove = function (comment) {
+  const remove = this.options.remove;
+
+  if (remove) {
+    return remove(comment);
+  } else {
+    const isImportant = comment.indexOf('!') === 0;
+
+    if (!isImportant) {
+      return true;
+    }
+
+    if (this.options.removeAll || this._hasFirst) {
+      return true;
+    } else if (this.options.removeAllButFirst && !this._hasFirst) {
+      this._hasFirst = true;
+      return false;
+    }
+  }
+};
+
+module.exports = CommentRemover;

Frontend-Learner/node_modules/postcss-discard-comments/types/index.d.ts

@@ -0,0 +1,22 @@
+export = pluginCreator;
+/** @typedef {object} Options
+ *  @property {boolean=} removeAll
+ *  @property {boolean=} removeAllButFirst
+ *  @property {(s: string) => boolean=} remove
+ */
+/**
+ * @type {import('postcss').PluginCreator<Options>}
+ * @param {Options} opts
+ * @return {import('postcss').Plugin}
+ */
+declare function pluginCreator(opts?: Options): import("postcss").Plugin;
+declare namespace pluginCreator {
+    export { postcss, Options };
+}
+declare var postcss: true;
+type Options = {
+    removeAll?: boolean | undefined;
+    removeAllButFirst?: boolean | undefined;
+    remove?: ((s: string) => boolean) | undefined;
+};
+//# sourceMappingURL=index.d.ts.map

Frontend-Learner/node_modules/postcss-discard-comments/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";AAKA;;;;GAIG;AACH;;;;GAIG;AACH,sCAHW,OAAO,GACN,OAAO,SAAS,EAAE,MAAM,CA8NnC;;;;;;gBArOc,OAAO,YAAC;wBACR,OAAO,YAAC;aACR,CAAA,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,aAAC"}

Frontend-Learner/node_modules/postcss-discard-comments/types/lib/commentParser.d.ts

@@ -0,0 +1,3 @@
+declare function _exports(input: string): [number, number, number][];
+export = _exports;
+//# sourceMappingURL=commentParser.d.ts.map

Frontend-Learner/node_modules/postcss-discard-comments/types/lib/commentParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commentParser.d.ts","sourceRoot":"","sources":["../../src/lib/commentParser.js"],"names":[],"mappings":"AAiBiB,iCAHN,MAAM,GACL,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CA+ErC"}

Frontend-Learner/node_modules/postcss-discard-comments/types/lib/commentRemover.d.ts

@@ -0,0 +1,15 @@
+export = CommentRemover;
+/** @param {import('../index.js').Options} options */
+declare function CommentRemover(options: import("../index.js").Options): void;
+declare class CommentRemover {
+    /** @param {import('../index.js').Options} options */
+    constructor(options: import("../index.js").Options);
+    options: import("../index.js").Options;
+    /**
+     * @param {string} comment
+     * @return {boolean | undefined}
+     */
+    canRemove(comment: string): boolean | undefined;
+    _hasFirst: boolean | undefined;
+}
+//# sourceMappingURL=commentRemover.d.ts.map

Frontend-Learner/node_modules/postcss-discard-comments/types/lib/commentRemover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commentRemover.d.ts","sourceRoot":"","sources":["../../src/lib/commentRemover.js"],"names":[],"mappings":";AAEA,qDAAqD;AACrD,yCADY,OAAO,aAAa,EAAE,OAAO,QAGxC;;IAHD,qDAAqD;IACrD,qBADY,OAAO,aAAa,EAAE,OAAO,EAGxC;IADC,uCAAsB;IAExB;;;OAGG;IACH,mBAHW,MAAM,GACL,OAAO,GAAG,SAAS,CAqB9B;IAJK,+BAAqB"}