nuxt-ignis 0.5.0 → 0.5.2

package/.output/server/node_modules/svgo/plugins/convertShapeToPath.js

@@ -1,29 +1,28 @@
-'use strict';
+import { stringifyPathData } from '../lib/path.js';
+import { detachNodeFromParent } from '../lib/xast.js';
 
 /**
- * @typedef {import('../lib/types').PathDataItem} PathDataItem
+ * @typedef ConvertShapeToPathParams
+ * @property {boolean=} convertArcs
+ * @property {number=} floatPrecision
  */
 
-const { stringifyPathData } = require('../lib/path.js');
-const { detachNodeFromParent } = require('../lib/xast.js');
-
-exports.name = 'convertShapeToPath';
-exports.description = 'converts basic shapes to more compact path form';
+export const name = 'convertShapeToPath';
+export const description = 'converts basic shapes to more compact path form';
 
 const regNumber = /[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g;
 
 /**
- * Converts basic shape to more compact path.
- * It also allows further optimizations like
- * combining paths with similar attributes.
+ * Converts basic shape to more compact path. It also allows further
+ * optimizations like combining paths with similar attributes.
  *
  * @see https://www.w3.org/TR/SVG11/shapes.html
  *
  * @author Lev Solntsev
  *
- * @type {import('./plugins-types').Plugin<'convertShapeToPath'>}
+ * @type {import('../lib/types.js').Plugin<ConvertShapeToPathParams>}
  */
-exports.fn = (root, params) => {
+export const fn = (root, params) => {
   const { convertArcs = false, floatPrecision: precision } = params;
 
   return {
@@ -44,10 +43,10 @@ exports.fn = (root, params) => {
           // Values like '100%' compute to NaN, thus running after
           // cleanupNumericValues when 'px' units has already been removed.
           // TODO: Calculate sizes from % and non-px units if possible.
-          if (Number.isNaN(x - y + width - height)) return;
-          /**
-           * @type {PathDataItem[]}
-           */
+          if (Number.isNaN(x - y + width - height)) {
+            return;
+          }
+          /** @type {import('../lib/types.js').PathDataItem[]} */
           const pathData = [
             { command: 'M', args: [x, y] },
             { command: 'H', args: [x + width] },
@@ -69,10 +68,10 @@ exports.fn = (root, params) => {
           const y1 = Number(node.attributes.y1 || '0');
           const x2 = Number(node.attributes.x2 || '0');
           const y2 = Number(node.attributes.y2 || '0');
-          if (Number.isNaN(x1 - y1 + x2 - y2)) return;
-          /**
-           * @type {PathDataItem[]}
-           */
+          if (Number.isNaN(x1 - y1 + x2 - y2)) {
+            return;
+          }
+          /** @type {import('../lib/types.js').PathDataItem[]} */
           const pathData = [
             { command: 'M', args: [x1, y1] },
             { command: 'L', args: [x2, y2] },
@@ -97,9 +96,7 @@ exports.fn = (root, params) => {
             detachNodeFromParent(node, parentNode);
             return;
           }
-          /**
-           * @type {PathDataItem[]}
-           */
+          /** @type {import('../lib/types.js').PathDataItem[]} */
           const pathData = [];
           for (let i = 0; i < coords.length; i += 2) {
             pathData.push({
@@ -123,9 +120,7 @@ exports.fn = (root, params) => {
           if (Number.isNaN(cx - cy + r)) {
             return;
           }
-          /**
-           * @type {PathDataItem[]}
-           */
+          /** @type {import('../lib/types.js').PathDataItem[]} */
           const pathData = [
             { command: 'M', args: [cx, cy - r] },
             { command: 'A', args: [r, r, 0, 1, 0, cx, cy + r] },
@@ -148,9 +143,7 @@ exports.fn = (root, params) => {
           if (Number.isNaN(ecx - ecy + rx - ry)) {
             return;
           }
-          /**
-           * @type {PathDataItem[]}
-           */
+          /** @type {import('../lib/types.js').PathDataItem[]} */
           const pathData = [
             { command: 'M', args: [ecx, ecy - ry] },
             { command: 'A', args: [rx, ry, 0, 1, 0, ecx, ecy + ry] },

package/.output/server/node_modules/svgo/plugins/convertStyleToAttrs.js

@@ -1,12 +1,16 @@
-'use strict';
+import { attrsGroups } from './_collections.js';
 
-const { attrsGroups } = require('./_collections');
+/**
+ * @typedef ConvertStyleToAttrsParams
+ * @property {boolean=} keepImportant
+ */
 
-exports.name = 'convertStyleToAttrs';
-exports.description = 'converts style to attributes';
+export const name = 'convertStyleToAttrs';
+export const description = 'converts style to attributes';
 
 /**
- * @type {(...args: string[]) => string}
+ * @param {...string} args
+ * @returns {string}
  */
 const g = (...args) => {
   return '(?:' + args.join('|') + ')';
@@ -14,9 +18,16 @@ const g = (...args) => {
 
 const stylingProps = attrsGroups.presentation;
 const rEscape = '\\\\(?:[0-9a-f]{1,6}\\s?|\\r\\n|.)'; // Like \" or \2051. Code points consume one space.
-const rAttr = '\\s*(' + g('[^:;\\\\]', rEscape) + '*?)\\s*'; // attribute name like ‘fill’
-const rSingleQuotes = "'(?:[^'\\n\\r\\\\]|" + rEscape + ")*?(?:'|$)"; // string in single quotes: 'smth'
-const rQuotes = '"(?:[^"\\n\\r\\\\]|' + rEscape + ')*?(?:"|$)'; // string in double quotes: "smth"
+
+/** Pattern to match attribute name like: 'fill' */
+const rAttr = '\\s*(' + g('[^:;\\\\]', rEscape) + '*?)\\s*';
+
+/** Pattern to match string in single quotes like: 'foo' */
+const rSingleQuotes = "'(?:[^'\\n\\r\\\\]|" + rEscape + ")*?(?:'|$)";
+
+/** Pattern to match string in double quotes like: "foo" */
+const rQuotes = '"(?:[^"\\n\\r\\\\]|' + rEscape + ')*?(?:"|$)';
+
 const rQuotedString = new RegExp('^' + g(rSingleQuotes, rQuotes) + '$');
 // Parentheses, E.g.: url(data:image/png;base64,iVBO...).
 // ':' and ';' inside of it should be treated as is. (Just like in strings.)
@@ -55,19 +66,19 @@ const regStripComments = new RegExp(
  *
  * @example
  * <g style="fill:#000; color: #fff;">
- *             ⬇
+ *  ⬇
  * <g fill="#000" color="#fff">
  *
  * @example
  * <g style="fill:#000; color: #fff; -webkit-blah: blah">
- *             ⬇
+ *  ⬇
  * <g fill="#000" color="#fff" style="-webkit-blah: blah">
  *
  * @author Kir Belevich
  *
- * @type {import('./plugins-types').Plugin<'convertStyleToAttrs'>}
+ * @type {import('../lib/types.js').Plugin<ConvertStyleToAttrsParams>}
  */
-exports.fn = (_root, params) => {
+export const fn = (_root, params) => {
   const { keepImportant = false } = params;
   return {
     element: {
@@ -75,9 +86,7 @@ exports.fn = (_root, params) => {
         if (node.attributes.style != null) {
           // ['opacity: 1', 'color: #000']
           let styles = [];
-          /**
-           * @type {Record<string, string>}
-           */
+          /** @type {Record<string, string>} */
           const newAttributes = {};
 
           // Strip CSS comments preserving escape sequences and strings.
@@ -102,8 +111,8 @@ exports.fn = (_root, params) => {
           if (styles.length) {
             styles = styles.filter(function (style) {
               if (style[0]) {
-                var prop = style[0].toLowerCase(),
-                  val = style[1];
+                const prop = style[0].toLowerCase();
+                let val = style[1];
 
                 if (rQuotedString.test(val)) {
                   val = val.slice(1, -1);

package/.output/server/node_modules/svgo/plugins/convertTransform.js

@@ -1,20 +1,48 @@
-'use strict';
+import {
+  js2transform,
+  matrixToTransform,
+  roundTransform,
+  transform2js,
+  transformsMultiply,
+} from './_transforms.js';
 
 /**
- * @typedef {import('../lib/types').XastChild} XastChild
- * @typedef {import('../lib/types').XastElement} XastElement
- * @typedef {import('../lib/types').XastParent} XastParent
+ * @typedef ConvertTransformParams
+ * @property {boolean=} convertToShorts
+ * @property {number=} degPrecision
+ * @property {number=} floatPrecision
+ * @property {number=} transformPrecision
+ * @property {boolean=} matrixToTransform
+ * @property {boolean=} shortTranslate
+ * @property {boolean=} shortScale
+ * @property {boolean=} shortRotate
+ * @property {boolean=} removeUseless
+ * @property {boolean=} collapseIntoOne
+ * @property {boolean=} leadingZero
+ * @property {boolean=} negativeExtraSpace
+ *
+ * @typedef TransformParams
+ * @property {boolean} convertToShorts
+ * @property {number=} degPrecision
+ * @property {number} floatPrecision
+ * @property {number} transformPrecision
+ * @property {boolean} matrixToTransform
+ * @property {boolean} shortTranslate
+ * @property {boolean} shortScale
+ * @property {boolean} shortRotate
+ * @property {boolean} removeUseless
+ * @property {boolean} collapseIntoOne
+ * @property {boolean} leadingZero
+ * @property {boolean} negativeExtraSpace
+ *
+ * @typedef TransformItem
+ * @property {string} name
+ * @property {number[]} data
  */
 
-const { cleanupOutData, toFixed } = require('../lib/svgo/tools.js');
-const {
-  transform2js,
-  transformsMultiply,
-  matrixToTransform,
-} = require('./_transforms.js');
-
-exports.name = 'convertTransform';
-exports.description = 'collapses multiple transformations and optimizes it';
+export const name = 'convertTransform';
+export const description =
+  'collapses multiple transformations and optimizes it';
 
 /**
  * Convert matrices to the short aliases,
@@ -26,9 +54,9 @@ exports.description = 'collapses multiple transformations and optimizes it';
  *
  * @author Kir Belevich
  *
- * @type {import('./plugins-types').Plugin<'convertTransform'>}
+ * @type {import('../lib/types.js').Plugin<ConvertTransformParams>}
  */
-exports.fn = (_root, params) => {
+export const fn = (_root, params) => {
   const {
     convertToShorts = true,
     // degPrecision = 3, // transformPrecision (or matrix precision) - 2 by default
@@ -78,28 +106,7 @@ exports.fn = (_root, params) => {
 };
 
 /**
- * @typedef {{
- *   convertToShorts: boolean,
- *   degPrecision?: number,
- *   floatPrecision: number,
- *   transformPrecision: number,
- *   matrixToTransform: boolean,
- *   shortTranslate: boolean,
- *   shortScale: boolean,
- *   shortRotate: boolean,
- *   removeUseless: boolean,
- *   collapseIntoOne: boolean,
- *   leadingZero: boolean,
- *   negativeExtraSpace: boolean,
- * }} TransformParams
- */
-
-/**
- * @typedef {{ name: string, data: number[] }} TransformItem
- */
-
-/**
- * @param {XastElement} item
+ * @param {import('../lib/types.js').XastElement} item
  * @param {string} attrName
  * @param {TransformParams} params
  */
@@ -130,14 +137,17 @@ const convertTransform = (item, attrName, params) => {
 
 /**
  * Defines precision to work with certain parts.
- * transformPrecision - for scale and four first matrix parameters (needs a better precision due to multiplying),
- * floatPrecision - for translate including two last matrix and rotate parameters,
- * degPrecision - for rotate and skew. By default it's equal to (roughly)
- * transformPrecision - 2 or floatPrecision whichever is lower. Can be set in params.
  *
- * @type {(data: TransformItem[], params: TransformParams) => TransformParams}
+ * - `transformPrecision` - for scale and four first matrix parameters (needs a better precision due to multiplying).
+ * - `floatPrecision` - for translate including two last matrix and rotate parameters.
+ * - `degPrecision` - for rotate and skew. By default it's equal to (roughly).
+ * - `transformPrecision` - 2 or floatPrecision whichever is lower. Can be set in params.
  *
- * clone params so it don't affect other elements transformations.
+ * Clone parameters so that it doesn't affect other element transformations.
+ *
+ * @param {ReadonlyArray<TransformItem>} data
+ * @param {TransformParams} param1
+ * @returns {TransformParams}
  */
 const definePrecision = (data, { ...newParams }) => {
   const matrixData = [];
@@ -161,7 +171,7 @@ const definePrecision = (data, { ...newParams }) => {
       ),
     );
   }
-  // No sense in angle precision more then number of significant digits in matrix.
+  // No sense in angle precision more than number of significant digits in matrix.
   if (newParams.degPrecision == null) {
     newParams.degPrecision = Math.max(
       0,
@@ -172,45 +182,11 @@ const definePrecision = (data, { ...newParams }) => {
 };
 
 /**
- * @type {(data: number[], params: TransformParams) => number[]}
- */
-const degRound = (data, params) => {
-  if (
-    params.degPrecision != null &&
-    params.degPrecision >= 1 &&
-    params.floatPrecision < 20
-  ) {
-    return smartRound(params.degPrecision, data);
-  } else {
-    return round(data);
-  }
-};
-/**
- * @type {(data: number[], params: TransformParams) => number[]}
- */
-const floatRound = (data, params) => {
-  if (params.floatPrecision >= 1 && params.floatPrecision < 20) {
-    return smartRound(params.floatPrecision, data);
-  } else {
-    return round(data);
-  }
-};
-
-/**
- * @type {(data: number[], params: TransformParams) => number[]}
- */
-const transformRound = (data, params) => {
-  if (params.transformPrecision >= 1 && params.floatPrecision < 20) {
-    return smartRound(params.transformPrecision, data);
-  } else {
-    return round(data);
-  }
-};
-
-/**
- * Returns number of digits after the point. 0.125 → 3
+ * Returns number of digits after the point.
  *
- * @type {(n: number) => number}
+ * @example 0.125 → 3
+ * @param {number} n
+ * @returns {number}
  */
 const floatDigits = (n) => {
   const str = n.toString();
@@ -225,12 +201,12 @@ const floatDigits = (n) => {
  * @returns {TransformItem[]}
  */
 const convertToShorts = (transforms, params) => {
-  for (var i = 0; i < transforms.length; i++) {
+  for (let i = 0; i < transforms.length; i++) {
     let transform = transforms[i];
 
     // convert matrix to the short aliases
     if (params.matrixToTransform && transform.name === 'matrix') {
-      var decomposed = matrixToTransform(transform, params);
+      const decomposed = matrixToTransform(transform, params);
       if (
         js2transform(decomposed, params).length <=
         js2transform([transform], params).length
@@ -296,7 +272,8 @@ const convertToShorts = (transforms, params) => {
 /**
  * Remove useless transforms.
  *
- * @type {(transforms: TransformItem[]) => TransformItem[]}
+ * @param {ReadonlyArray<TransformItem>} transforms
+ * @returns {TransformItem[]}
  */
 const removeUseless = (transforms) => {
   return transforms.filter((transform) => {
@@ -330,89 +307,3 @@ const removeUseless = (transforms) => {
     return true;
   });
 };
-
-/**
- * Convert transforms JS representation to string.
- *
- * @param {TransformItem[]} transformJS
- * @param {TransformParams} params
- * @returns {string}
- */
-const js2transform = (transformJS, params) => {
-  const transformString = transformJS
-    .map((transform) => {
-      roundTransform(transform, params);
-      return `${transform.name}(${cleanupOutData(transform.data, params)})`;
-    })
-    .join('');
-
-  return transformString;
-};
-
-/**
- * @type {(transform: TransformItem, params: TransformParams) => TransformItem}
- */
-const roundTransform = (transform, params) => {
-  switch (transform.name) {
-    case 'translate':
-      transform.data = floatRound(transform.data, params);
-      break;
-    case 'rotate':
-      transform.data = [
-        ...degRound(transform.data.slice(0, 1), params),
-        ...floatRound(transform.data.slice(1), params),
-      ];
-      break;
-    case 'skewX':
-    case 'skewY':
-      transform.data = degRound(transform.data, params);
-      break;
-    case 'scale':
-      transform.data = transformRound(transform.data, params);
-      break;
-    case 'matrix':
-      transform.data = [
-        ...transformRound(transform.data.slice(0, 4), params),
-        ...floatRound(transform.data.slice(4), params),
-      ];
-      break;
-  }
-  return transform;
-};
-
-/**
- * Rounds numbers in array.
- *
- * @type {(data: number[]) => number[]}
- */
-const round = (data) => {
-  return data.map(Math.round);
-};
-
-/**
- * Decrease accuracy of floating-point numbers
- * in transforms keeping a specified number of decimals.
- * Smart rounds values like 2.349 to 2.35.
- *
- * @param {number} precision
- * @param {number[]} data
- * @returns {number[]}
- */
-const smartRound = (precision, data) => {
-  for (
-    var i = data.length,
-      tolerance = +Math.pow(0.1, precision).toFixed(precision);
-    i--;
-
-  ) {
-    if (toFixed(data[i], precision) !== data[i]) {
-      var rounded = +data[i].toFixed(precision - 1);
-      data[i] =
-        +Math.abs(rounded - data[i]).toFixed(precision + 1) >= tolerance
-          ? +data[i].toFixed(precision)
-          : rounded;
-    }
-  }
-
-  return data;
-};

package/.output/server/node_modules/svgo/plugins/inlineStyles.js

@@ -1,32 +1,33 @@
-'use strict';
+import * as csstree from 'css-tree';
+import { syntax } from 'csso';
+import { attrsGroups, pseudoClasses } from './_collections.js';
+import { detachNodeFromParent, querySelectorAll } from '../lib/xast.js';
+import { visitSkip } from '../lib/util/visit.js';
+import { compareSpecificity, includesAttrSelector } from '../lib/style.js';
 
 /**
- * @typedef {import('../lib/types').XastElement} XastElement
- * @typedef {import('../lib/types').XastParent} XastParent
+ * @typedef InlineStylesParams
+ * @property {boolean=} onlyMatchedOnce Inlines selectors that match once only.
+ * @property {boolean=} removeMatchedSelectors
+ *   Clean up matched selectors. Unused selects are left as-is.
+ * @property {string[]=} useMqs
+ *   Media queries to use. An empty string indicates all selectors outside of
+ *   media queries.
+ * @property {string[]=} usePseudos
+ *   Pseudo-classes and elements to use. An empty string indicates all
+ *   non-pseudo-classes and elements.
  */
 
-const csstree = require('css-tree');
-const {
-  syntax: { specificity },
-} = require('csso');
-const {
-  visitSkip,
-  querySelectorAll,
-  detachNodeFromParent,
-} = require('../lib/xast.js');
-const { compareSpecificity, includesAttrSelector } = require('../lib/style');
-const { attrsGroups, pseudoClasses } = require('./_collections');
-
-exports.name = 'inlineStyles';
-exports.description = 'inline styles (additional options)';
+export const name = 'inlineStyles';
+export const description = 'inline styles (additional options)';
 
 /**
  * Some pseudo-classes can only be calculated by clients, like :visited,
  * :future, or :hover, but there are other pseudo-classes that we can evaluate
  * during optimization.
  *
- * The list of pseudo-classes that we can evaluate during optimization, and so
- * shouldn't be toggled conditionally through the `usePseudos` parameter.
+ * Pseudo-classes that we can evaluate during optimization, and shouldn't be
+ * toggled conditionally through the `usePseudos` parameter.
  *
  * @see https://developer.mozilla.org/docs/Web/CSS/Pseudo-classes
  */
@@ -38,10 +39,10 @@ const preservedPseudos = [
 /**
  * Merges styles from style nodes into inline styles.
  *
- * @type {import('./plugins-types').Plugin<'inlineStyles'>}
+ * @type {import('../lib/types.js').Plugin<InlineStylesParams>}
  * @author strarsis <strarsis@gmail.com>
  */
-exports.fn = (root, params) => {
+export const fn = (root, params) => {
   const {
     onlyMatchedOnce = true,
     removeMatchedSelectors = true,
@@ -50,7 +51,11 @@ exports.fn = (root, params) => {
   } = params;
 
   /**
-   * @type {{ node: XastElement, parentNode: XastParent, cssAst: csstree.StyleSheet }[]}
+   * @type {{
+   *   node: import('../lib/types.js').XastElement,
+   *   parentNode: import('../lib/types.js').XastParent,
+   *   cssAst: csstree.StyleSheet
+   * }[]}
    */
   const styles = [];
   /**
@@ -58,10 +63,10 @@ exports.fn = (root, params) => {
    *   node: csstree.Selector,
    *   item: csstree.ListItem<csstree.CssNode>,
    *   rule: csstree.Rule,
-   *   matchedElements?: XastElement[]
+   *   matchedElements?: import('../lib/types.js').XastElement[]
    * }[]}
    */
-  let selectors = [];
+  const selectors = [];
 
   return {
     element: {
@@ -82,7 +87,6 @@ exports.fn = (root, params) => {
 
         const cssText = node.children
           .filter((child) => child.type === 'text' || child.type === 'cdata')
-          // @ts-ignore
           .map((child) => child.value)
           .join('');
 
@@ -177,8 +181,8 @@ exports.fn = (root, params) => {
         const sortedSelectors = selectors
           .slice()
           .sort((a, b) => {
-            const aSpecificity = specificity(a.item.data);
-            const bSpecificity = specificity(b.item.data);
+            const aSpecificity = syntax.specificity(a.item.data);
+            const bSpecificity = syntax.specificity(b.item.data);
             return compareSpecificity(aSpecificity, bSpecificity);
           })
           .reverse();
@@ -186,7 +190,7 @@ exports.fn = (root, params) => {
         for (const selector of sortedSelectors) {
           // match selectors
           const selectorText = csstree.generate(selector.item.data);
-          /** @type {XastElement[]} */
+          /** @type {import('../lib/types.js').XastElement[]} */
           const matchedElements = [];
           try {
             for (const node of querySelectorAll(root, selectorText)) {
@@ -194,7 +198,7 @@ exports.fn = (root, params) => {
                 matchedElements.push(node);
               }
             }
-          } catch (selectError) {
+          } catch {
             continue;
           }
           // nothing selected
@@ -372,7 +376,6 @@ exports.fn = (root, params) => {
             },
           });
 
-          // csstree v2 changed this type
           if (style.cssAst.children.isEmpty) {
             // remove empty style element
             detachNodeFromParent(style.node, style.parentNode);