up n_m

node_modules/postcss-reduce-idents/src/index.js

@@ -0,0 +1,52 @@
+'use strict';
+const encode = require('./lib/encode');
+const counterReducer = require('./lib/counter');
+const counterStyleReducer = require('./lib/counter-style');
+const keyframesReducer = require('./lib/keyframes');
+const gridTemplateReducer = require('./lib/grid-template');
+
+/** @typedef {{
+    counter?: boolean, counterStyle?: boolean, 
+    keyframes?: boolean, gridTemplate?: boolean, 
+    encoder?: (value: string, index: number) => string}} Options
+*/
+/** @typedef {{
+ *    collect: (node: import('postcss').AnyNode, encoder: (value: string, num: number) => string) => void,
+ *    transform: () => void
+ *  }} Reducer
+ */
+/**
+ * @type {import('postcss').PluginCreator<Options>}
+ * @param {Options} arg
+ * @return {import('postcss').Plugin}
+ */
+function pluginCreator({
+  counter = true,
+  counterStyle = true,
+  keyframes = true,
+  gridTemplate = true,
+  encoder = encode,
+} = {}) {
+  /** @type {Reducer[]} */
+  const reducers = [];
+
+  counter && reducers.push(counterReducer());
+  counterStyle && reducers.push(counterStyleReducer());
+  keyframes && reducers.push(keyframesReducer());
+  gridTemplate && reducers.push(gridTemplateReducer());
+
+  return {
+    postcssPlugin: 'postcss-reduce-idents',
+
+    OnceExit(css) {
+      css.walk((node) => {
+        reducers.forEach((reducer) => reducer.collect(node, encoder));
+      });
+
+      reducers.forEach((reducer) => reducer.transform());
+    },
+  };
+}
+
+pluginCreator.postcss = true;
+module.exports = pluginCreator;

node_modules/postcss-reduce-idents/src/lib/cache.js

@@ -0,0 +1,17 @@
+'use strict';
+/**
+ * @param {string} value
+ * @param {(value: string, num: number) => string} encoder
+ * @param {Record<string, {ident: string, count: number}>} cache
+ * @return {void}
+ */
+module.exports = function (value, encoder, cache) {
+  if (cache[value]) {
+    return;
+  }
+
+  cache[value] = {
+    ident: encoder(value, Object.keys(cache).length),
+    count: 0,
+  };
+};

node_modules/postcss-reduce-idents/src/lib/counter-style.js

@@ -0,0 +1,127 @@
+'use strict';
+const valueParser = require('postcss-value-parser');
+const addToCache = require('./cache');
+
+const RESERVED_KEYWORDS = new Set([
+  'unset',
+  'initial',
+  'inherit',
+  'none',
+  'inline',
+  'outside',
+  'disc',
+  'circle',
+  'square',
+  'decimal',
+  'cjk-decimal',
+  'decimal-leading-zero',
+  'lower-roman',
+  'upper-roman',
+  'lower-greek',
+  'lower-alpha',
+  'lower-latin',
+  'upper-alpha',
+  'upper-latin',
+  'arabic-indic',
+  'armenian',
+  'bengali',
+  'cambodian',
+  'cjk-earthly-branch',
+  'cjk-heavenly-stem',
+  'cjk-ideographic',
+  'devanagari',
+  'ethiopic-numeric',
+  'georgian',
+  'gujarati',
+  'gurmukhi',
+  'hebrew',
+  'hiragana',
+  'hiragana-iroha',
+  'japanese-formal',
+  'japanese-informal',
+  'kannada',
+  'katakana',
+  'katakana-iroha',
+  'khmer',
+  'korean-hangul-formal',
+  'korean-hanja-formal',
+  'korean-hanja-informal',
+  'lao',
+  'lower-armenian',
+  'malayalam',
+  'mongolian',
+  'myanmar',
+  'oriya',
+  'persian',
+  'simp-chinese-formal',
+  'simp-chinese-informal',
+  'tamil',
+  'telugu',
+  'thai',
+  'tibetan',
+  'trad-chinese-formal',
+  'trad-chinese-informal',
+  'upper-armenian',
+  'disclosure-open',
+  'disclosure-close',
+]);
+
+/**
+ * @return {import('../index.js').Reducer}
+ */
+module.exports = function () {
+  /** @type {Record<string, {ident: string, count: number}>} */
+  let cache = {};
+  /** @type {import('postcss').AtRule[]} */
+  let atRules = [];
+  /** @type {import('postcss').Declaration[]} */
+  let decls = [];
+
+  return {
+    collect(node, encoder) {
+      const { type } = node;
+
+      if (
+        type === 'atrule' &&
+        /counter-style/i.test(node.name) &&
+        !RESERVED_KEYWORDS.has(node.params.toLowerCase())
+      ) {
+        addToCache(node.params, encoder, cache);
+
+        atRules.push(node);
+      }
+
+      if (type === 'decl' && /(list-style|system)/i.test(node.prop)) {
+        decls.push(node);
+      }
+    },
+
+    transform() {
+      // Iterate each property and change their names
+      decls.forEach((decl) => {
+        decl.value = valueParser(decl.value)
+          .walk((node) => {
+            if (node.type === 'word' && node.value in cache) {
+              cache[node.value].count++;
+
+              node.value = cache[node.value].ident;
+            }
+          })
+          .toString();
+      });
+
+      // Iterate each at rule and change their name if references to them have been found
+      atRules.forEach((rule) => {
+        const cached = cache[rule.params];
+
+        if (cached && cached.count > 0) {
+          rule.params = cached.ident;
+        }
+      });
+
+      // reset cache after transform
+      atRules = [];
+      decls = [];
+    },
+  };
+};

node_modules/postcss-reduce-idents/src/lib/counter.js

@@ -0,0 +1,100 @@
+'use strict';
+const valueParser = require('postcss-value-parser');
+const addToCache = require('./cache');
+const isNum = require('./isNum');
+
+const RESERVED_KEYWORDS = new Set(['unset', 'initial', 'inherit', 'none']);
+
+/**
+ * @return {import('../index.js').Reducer}
+ */
+module.exports = function () {
+  /** @type {Record<string, {ident: string, count: number}>} */
+  let cache = {};
+  /** @type {{value: import('postcss-value-parser').ParsedValue}[]} */
+  let declOneCache = [];
+  /** @type {import('postcss').Declaration[]} */
+  let declTwoCache = [];
+
+  return {
+    collect(node, encoder) {
+      const { type } = node;
+
+      if (type !== 'decl') {
+        return;
+      }
+      const { prop } = node;
+
+      if (/counter-(reset|increment)/i.test(prop)) {
+        /** @type {unknown} */ (node.value) = valueParser(node.value).walk(
+          (child) => {
+            if (
+              child.type === 'word' &&
+              !isNum(child) &&
+              !RESERVED_KEYWORDS.has(child.value.toLowerCase())
+            ) {
+              addToCache(child.value, encoder, cache);
+
+              child.value = cache[child.value].ident;
+            }
+          }
+        );
+
+        declOneCache.push(/** @type {any} */ (node));
+      } else if (/content/i.test(prop)) {
+        declTwoCache.push(node);
+      }
+    },
+
+    transform() {
+      declTwoCache.forEach((decl) => {
+        decl.value = valueParser(decl.value)
+          .walk((node) => {
+            const { type } = node;
+
+            const value = node.value.toLowerCase();
+
+            if (
+              type === 'function' &&
+              (value === 'counter' || value === 'counters')
+            ) {
+              valueParser.walk(node.nodes, (child) => {
+                if (child.type === 'word' && child.value in cache) {
+                  cache[child.value].count++;
+
+                  child.value = cache[child.value].ident;
+                }
+              });
+            }
+
+            if (type === 'space') {
+              node.value = ' ';
+            }
+
+            return false;
+          })
+          .toString();
+      });
+
+      declOneCache.forEach((decl) => {
+        /** @type {unknown} */ (decl.value) = decl.value
+          .walk((node) => {
+            if (node.type === 'word' && !isNum(node)) {
+              Object.keys(cache).forEach((key) => {
+                const cached = cache[key];
+
+                if (cached.ident === node.value && !cached.count) {
+                  node.value = key;
+                }
+              });
+            }
+          })
+          .toString();
+      });
+
+      // reset cache after transform
+      declOneCache = [];
+      declTwoCache = [];
+    },
+  };
+};

node_modules/postcss-reduce-idents/src/lib/encode.js

@@ -0,0 +1,27 @@
+'use strict';
+/**
+ * @param {string} val
+ * @param {number} num
+ * @return {string}
+ */
+module.exports = function encode(val, num) {
+  let base = 52;
+  let characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  let character = num % base;
+  let result = characters[character];
+  let remainder = Math.floor(num / base);
+
+  if (remainder) {
+    base = 64;
+    characters = characters + '0123456789-_';
+
+    while (remainder) {
+      remainder--;
+      character = remainder % base;
+      remainder = Math.floor(remainder / base);
+      result = result + characters[character];
+    }
+  }
+
+  return result;
+};

node_modules/postcss-reduce-idents/src/lib/grid-template.js

@@ -0,0 +1,104 @@
+'use strict';
+const valueParser = require('postcss-value-parser');
+const addToCache = require('./cache');
+const isNum = require('./isNum');
+
+const RESERVED_KEYWORDS = new Set([
+  'auto',
+  'span',
+  'inherit',
+  'initial',
+  'unset',
+]);
+
+const gridTemplateProperties = new Set([
+  'grid-template',
+  'grid-template-areas',
+]);
+
+const gridChildProperties = new Set([
+  'grid-area',
+  'grid-column',
+  'grid-row',
+  'grid-column-start',
+  'grid-column-end',
+  'grid-row-start',
+  'grid-row-end',
+]);
+
+/**
+ * @return {import('../index.js').Reducer}
+ */
+module.exports = function () {
+  /** @type {Record<string, {ident: string, count: number}>} */
+  let cache = {};
+  /** @type {import('postcss').Declaration[]} */
+  let declCache = [];
+
+  return {
+    collect(node, encoder) {
+      if (node.type !== 'decl') {
+        return;
+      }
+
+      if (gridTemplateProperties.has(node.prop.toLowerCase())) {
+        valueParser(node.value).walk((child) => {
+          if (child.type === 'string') {
+            child.value.split(/\s+/).forEach((word) => {
+              if (/\.+/.test(word)) {
+                // reduce empty zones to a single `.`
+                node.value = node.value.replace(word, '.');
+              } else if (word && !RESERVED_KEYWORDS.has(word.toLowerCase())) {
+                addToCache(word, encoder, cache);
+              }
+            });
+          }
+        });
+
+        declCache.push(node);
+      } else if (gridChildProperties.has(node.prop.toLowerCase())) {
+        valueParser(node.value).walk((child) => {
+          if (
+            child.type === 'word' &&
+            !RESERVED_KEYWORDS.has(child.value.toLowerCase())
+          ) {
+            addToCache(child.value, encoder, cache);
+          }
+        });
+
+        declCache.push(node);
+      }
+    },
+
+    transform() {
+      declCache.forEach((decl) => {
+        decl.value = valueParser(decl.value)
+          .walk((node) => {
+            if (gridTemplateProperties.has(decl.prop.toLowerCase())) {
+              node.value.split(/\s+/).forEach((word) => {
+                if (word in cache) {
+                  node.value = node.value.replace(word, cache[word].ident);
+                }
+              });
+              node.value = node.value.replace(/\s+/g, ' '); // merge white-spaces
+            }
+
+            if (
+              gridChildProperties.has(decl.prop.toLowerCase()) &&
+              !isNum(node)
+            ) {
+              if (node.value in cache) {
+                node.value = cache[node.value].ident;
+              }
+            }
+
+            return false;
+          })
+          .toString();
+      });
+
+      // reset cache after transform
+      declCache = [];
+    },
+  };
+};

node_modules/postcss-reduce-idents/src/lib/isNum.js

@@ -0,0 +1,10 @@
+'use strict';
+const { unit } = require('postcss-value-parser');
+
+/**
+ * @param {import('postcss-value-parser').Node} node
+ * @return {import('postcss-value-parser').Dimension | false}
+ */
+module.exports = function isNum(node) {
+  return unit(node.value);
+};

node_modules/postcss-reduce-idents/src/lib/keyframes.js

@@ -0,0 +1,69 @@
+'use strict';
+const valueParser = require('postcss-value-parser');
+const addToCache = require('./cache');
+
+const RESERVED_KEYWORDS = new Set(['none', 'inherit', 'initial', 'unset']);
+
+/**
+ * @return {import('../index.js').Reducer}
+ */
+module.exports = function () {
+  /** @type {Record<string, {ident: string, count: number}>} */
+  let cache = {};
+  /** @type {import('postcss').AtRule[]} */
+  let atRules = [];
+  /** @type {import('postcss').Declaration[]} */
+  let decls = [];
+
+  return {
+    collect(node, encoder) {
+      const { type } = node;
+
+      if (
+        type === 'atrule' &&
+        /keyframes/i.test(node.name) &&
+        !RESERVED_KEYWORDS.has(node.params.toLowerCase())
+      ) {
+        addToCache(node.params, encoder, cache);
+        atRules.push(node);
+      }
+
+      if (type === 'decl' && /animation/i.test(node.prop)) {
+        decls.push(node);
+      }
+    },
+
+    transform() {
+      const referenced = new Set();
+
+      // Iterate each property and change their names
+      decls.forEach((decl) => {
+        decl.value = valueParser(decl.value)
+          .walk((node) => {
+            if (node.type === 'word' && node.value in cache) {
+              if (!referenced.has(node.value)) {
+                referenced.add(node.value);
+              }
+
+              cache[node.value].count++;
+              node.value = cache[node.value].ident;
+            }
+          })
+          .toString();
+      });
+
+      // Iterate each at rule and change their name if references to them have been found
+      atRules.forEach((rule) => {
+        const cached = cache[rule.params];
+
+        if (cached && cached.count > 0 && referenced.has(rule.params)) {
+          rule.params = cached.ident;
+        }
+      });
+
+      // reset cache after transform
+      atRules = [];
+      decls = [];
+    },
+  };
+};