nuxt-ignis 0.5.0 → 0.5.2

package/.output/server/node_modules/svgo/lib/style.js

@@ -1,40 +1,23 @@
-'use strict';
-
-/**
- * @typedef {import('css-tree').Rule} CsstreeRule
- * @typedef {import('./types').Specificity} Specificity
- * @typedef {import('./types').Stylesheet} Stylesheet
- * @typedef {import('./types').StylesheetRule} StylesheetRule
- * @typedef {import('./types').StylesheetDeclaration} StylesheetDeclaration
- * @typedef {import('./types').ComputedStyles} ComputedStyles
- * @typedef {import('./types').XastRoot} XastRoot
- * @typedef {import('./types').XastElement} XastElement
- * @typedef {import('./types').XastParent} XastParent
- * @typedef {import('./types').XastChild} XastChild
- */
-
-const csstree = require('css-tree');
-const csswhat = require('css-what');
-const {
-  syntax: { specificity },
-} = require('csso');
-const { visit, matches } = require('./xast.js');
-const {
+import * as csstree from 'css-tree';
+import * as csswhat from 'css-what';
+import { syntax } from 'csso';
+import { matches } from './xast.js';
+import { visit } from './util/visit.js';
+import {
   attrsGroups,
   inheritableAttrs,
   presentationNonInheritableGroupAttrs,
-} = require('../plugins/_collections.js');
+} from '../plugins/_collections.js';
 
-// @ts-ignore not defined in @types/csstree
 const csstreeWalkSkip = csstree.walk.skip;
 
 /**
- * @type {(ruleNode: CsstreeRule, dynamic: boolean) => StylesheetRule[]}
+ * @param {import('css-tree').Rule} ruleNode
+ * @param {boolean} dynamic
+ * @returns {import('./types.js').StylesheetRule[]}
  */
 const parseRule = (ruleNode, dynamic) => {
-  /**
-   * @type {StylesheetDeclaration[]}
-   */
+  /** @type {import('./types.js').StylesheetDeclaration[]} */
   const declarations = [];
   // collect declarations
   ruleNode.block.children.forEach((cssNode) => {
@@ -47,7 +30,7 @@ const parseRule = (ruleNode, dynamic) => {
     }
   });
 
-  /** @type {StylesheetRule[]} */
+  /** @type {import('./types.js').StylesheetRule[]} */
   const rules = [];
   csstree.walk(ruleNode.prelude, (node) => {
     if (node.type === 'Selector') {
@@ -60,7 +43,7 @@ const parseRule = (ruleNode, dynamic) => {
         }
       });
       rules.push({
-        specificity: specificity(node),
+        specificity: syntax.specificity(node),
         dynamic: hasPseudoClasses || dynamic,
         // compute specificity from original node to consider pseudo classes
         selector: csstree.generate(newNode),
@@ -73,10 +56,12 @@ const parseRule = (ruleNode, dynamic) => {
 };
 
 /**
- * @type {(css: string, dynamic: boolean) => StylesheetRule[]}
+ * @param {string} css
+ * @param {boolean} dynamic
+ * @returns {import('./types.js').StylesheetRule[]}
  */
 const parseStylesheet = (css, dynamic) => {
-  /** @type {StylesheetRule[]} */
+  /** @type {import('./types.js').StylesheetRule[]} */
   const rules = [];
   const ast = csstree.parse(css, {
     parseValue: false,
@@ -89,8 +74,12 @@ const parseStylesheet = (css, dynamic) => {
     }
     if (cssNode.type === 'Atrule') {
       if (
-        cssNode.name === 'keyframes' ||
-        cssNode.name === '-webkit-keyframes'
+        [
+          'keyframes',
+          '-webkit-keyframes',
+          '-o-keyframes',
+          '-moz-keyframes',
+        ].includes(cssNode.name)
       ) {
         return csstreeWalkSkip;
       }
@@ -107,10 +96,11 @@ const parseStylesheet = (css, dynamic) => {
 };
 
 /**
- * @type {(css: string) => StylesheetDeclaration[]}
+ * @param {string} css
+ * @returns {import('./types.js').StylesheetDeclaration[]}
  */
 const parseStyleDeclarations = (css) => {
-  /** @type {StylesheetDeclaration[]} */
+  /** @type {import('./types.js').StylesheetDeclaration[]} */
   const declarations = [];
   const ast = csstree.parse(css, {
     context: 'declarationList',
@@ -129,12 +119,13 @@ const parseStyleDeclarations = (css) => {
 };
 
 /**
- * @param {Stylesheet} stylesheet
- * @param {XastElement} node
- * @returns {ComputedStyles}
+ * @param {import('./types.js').Stylesheet} stylesheet
+ * @param {import('./types.js').XastElement} node
+ * @param {Map<import('./types.js').XastNode, import('./types.js').XastParent>=} parents
+ * @returns {import('./types.js').ComputedStyles}
  */
-const computeOwnStyle = (stylesheet, node) => {
-  /** @type {ComputedStyles} */
+const computeOwnStyle = (stylesheet, node, parents) => {
+  /** @type {import('./types.js').ComputedStyles} */
   const computedStyle = {};
   const importantStyles = new Map();
 
@@ -148,7 +139,7 @@ const computeOwnStyle = (stylesheet, node) => {
 
   // collect matching rules
   for (const { selector, declarations, dynamic } of stylesheet.rules) {
-    if (matches(node, selector)) {
+    if (matches(node, selector, parents)) {
       for (const { name, value, important } of declarations) {
         const computed = computedStyle[name];
         if (computed && computed.type === 'dynamic') {
@@ -197,11 +188,11 @@ const computeOwnStyle = (stylesheet, node) => {
  * Compares selector specificities.
  * Derived from https://github.com/keeganstreet/specificity/blob/8757133ddd2ed0163f120900047ff0f92760b536/specificity.js#L207
  *
- * @param {Specificity} a
- * @param {Specificity} b
+ * @param {import('./types.js').Specificity} a
+ * @param {import('./types.js').Specificity} b
  * @returns {number}
  */
-const compareSpecificity = (a, b) => {
+export const compareSpecificity = (a, b) => {
   for (let i = 0; i < 4; i += 1) {
     if (a[i] < b[i]) {
       return -1;
@@ -212,15 +203,15 @@ const compareSpecificity = (a, b) => {
 
   return 0;
 };
-exports.compareSpecificity = compareSpecificity;
 
 /**
- * @type {(root: XastRoot) => Stylesheet}
+ * @param {import('./types.js').XastRoot} root
+ * @returns {import('./types.js').Stylesheet}
  */
-const collectStylesheet = (root) => {
-  /** @type {StylesheetRule[]} */
+export const collectStylesheet = (root) => {
+  /** @type {import('./types.js').StylesheetRule[]} */
   const rules = [];
-  /** @type {Map<XastElement, XastParent>} */
+  /** @type {Map<import('./types.js').XastElement, import('./types.js').XastParent>} */
   const parents = new Map();
 
   visit(root, {
@@ -253,19 +244,18 @@ const collectStylesheet = (root) => {
   rules.sort((a, b) => compareSpecificity(a.specificity, b.specificity));
   return { rules, parents };
 };
-exports.collectStylesheet = collectStylesheet;
 
 /**
- * @param {Stylesheet} stylesheet
- * @param {XastElement} node
- * @returns {ComputedStyles}
+ * @param {import('./types.js').Stylesheet} stylesheet
+ * @param {import('./types.js').XastElement} node
+ * @returns {import('./types.js').ComputedStyles}
  */
-const computeStyle = (stylesheet, node) => {
+export const computeStyle = (stylesheet, node) => {
   const { parents } = stylesheet;
-  const computedStyles = computeOwnStyle(stylesheet, node);
+  const computedStyles = computeOwnStyle(stylesheet, node, parents);
   let parent = parents.get(node);
   while (parent != null && parent.type !== 'root') {
-    const inheritedStyles = computeOwnStyle(stylesheet, parent);
+    const inheritedStyles = computeOwnStyle(stylesheet, parent, parents);
     for (const [name, computed] of Object.entries(inheritedStyles)) {
       if (
         computedStyles[name] == null &&
@@ -279,22 +269,21 @@ const computeStyle = (stylesheet, node) => {
   }
   return computedStyles;
 };
-exports.computeStyle = computeStyle;
 
 /**
  * Determines if the CSS selector includes or traverses the given attribute.
  *
- * Classes and IDs are generated as attribute selectors, so you can check for
- * if a `.class` or `#id` is included by passing `name=class` or `name=id`
+ * Classes and IDs are generated as attribute selectors, so you can check for if
+ * a `.class` or `#id` is included by passing `name=class` or `name=id`
  * respectively.
  *
- * @param {csstree.ListItem<csstree.CssNode>|string} selector
+ * @param {csstree.ListItem<csstree.CssNode> | string} selector
  * @param {string} name
  * @param {?string} value
  * @param {boolean} traversed
  * @returns {boolean}
  */
-const includesAttrSelector = (
+export const includesAttrSelector = (
   selector,
   name,
   value = null,
@@ -333,4 +322,3 @@ const includesAttrSelector = (
 
   return false;
 };
-exports.includesAttrSelector = includesAttrSelector;

package/.output/server/node_modules/svgo/lib/svgo/css-select-adapter.js

@@ -1,79 +1,46 @@
-'use strict';
+import { mapNodesToParents } from '../util/map-nodes-to-parents.js';
 
+/** @type {Required<import('css-select').Options<import('../types.js').XastNode & { children?: any }, import('../types.js').XastElement>>['adapter']['isTag']} */
 const isTag = (node) => {
   return node.type === 'element';
 };
 
+/** @type {Required<import('css-select').Options<import('../types.js').XastNode & { children?: any }, import('../types.js').XastElement>>['adapter']['existsOne']} */
 const existsOne = (test, elems) => {
   return elems.some((elem) => {
-    if (isTag(elem)) {
-      return test(elem) || existsOne(test, getChildren(elem));
-    } else {
-      return false;
-    }
+    return isTag(elem) && (test(elem) || existsOne(test, getChildren(elem)));
   });
 };
 
+/** @type {Required<import('css-select').Options<import('../types.js').XastNode & { children?: any }, import('../types.js').XastElement>>['adapter']['getAttributeValue']} */
 const getAttributeValue = (elem, name) => {
   return elem.attributes[name];
 };
 
+/** @type {Required<import('css-select').Options<import('../types.js').XastNode & { children?: any }, import('../types.js').XastElement>>['adapter']['getChildren']} */
 const getChildren = (node) => {
   return node.children || [];
 };
 
+/** @type {Required<import('css-select').Options<import('../types.js').XastNode & { children?: any }, import('../types.js').XastElement>>['adapter']['getName']} */
 const getName = (elemAst) => {
   return elemAst.name;
 };
 
-const getParent = (node) => {
-  return node.parentNode || null;
-};
-
-const getSiblings = (elem) => {
-  var parent = getParent(elem);
-  return parent ? getChildren(parent) : [];
-};
-
+/** @type {Required<import('css-select').Options<import('../types.js').XastNode & { children?: any }, import('../types.js').XastElement>>['adapter']['getText']} */
 const getText = (node) => {
-  if (node.children[0].type === 'text' && node.children[0].type === 'cdata') {
+  if (node.children[0].type === 'text' || node.children[0].type === 'cdata') {
     return node.children[0].value;
   }
   return '';
 };
 
+/** @type {Required<import('css-select').Options<import('../types.js').XastNode & { children?: any }, import('../types.js').XastElement>>['adapter']['hasAttrib']} */
 const hasAttrib = (elem, name) => {
   return elem.attributes[name] !== undefined;
 };
 
-const removeSubsets = (nodes) => {
-  let idx = nodes.length;
-  let node;
-  let ancestor;
-  let replace;
-  // Check if each node (or one of its ancestors) is already contained in the
-  // array.
-  while (--idx > -1) {
-    node = ancestor = nodes[idx];
-    // Temporarily remove the node under consideration
-    nodes[idx] = null;
-    replace = true;
-    while (ancestor) {
-      if (nodes.includes(ancestor)) {
-        replace = false;
-        nodes.splice(idx, 1);
-        break;
-      }
-      ancestor = getParent(ancestor);
-    }
-    // If the node has been found to be unique, re-insert it.
-    if (replace) {
-      nodes[idx] = node;
-    }
-  }
-  return nodes;
-};
-
+/** @type {Required<import('css-select').Options<import('../types.js').XastNode & { children?: any }, import('../types.js').XastElement>>['adapter']['findAll']} */
 const findAll = (test, elems) => {
   const result = [];
   for (const elem of elems) {
@@ -87,6 +54,7 @@ const findAll = (test, elems) => {
   return result;
 };
 
+/** @type {Required<import('css-select').Options<import('../types.js').XastNode & { children?: any }, import('../types.js').XastElement>>['adapter']['findOne']} */
 const findOne = (test, elems) => {
   for (const elem of elems) {
     if (isTag(elem)) {
@@ -102,19 +70,74 @@ const findOne = (test, elems) => {
   return null;
 };
 
-const svgoCssSelectAdapter = {
-  isTag,
-  existsOne,
-  getAttributeValue,
-  getChildren,
-  getName,
-  getParent,
-  getSiblings,
-  getText,
-  hasAttrib,
-  removeSubsets,
-  findAll,
-  findOne,
-};
+/**
+ * @param {import('../types.js').XastParent} relativeNode
+ * @param {Map<import('../types.js').XastNode, import('../types.js').XastParent>=} parents
+ * @returns {Required<import('css-select').Options<import('../types.js').XastNode & { children?: any }, import('../types.js').XastElement>>['adapter']}
+ */
+export function createAdapter(relativeNode, parents) {
+  /** @type {Required<import('css-select').Options<import('../types.js').XastNode & { children?: any }, import('../types.js').XastElement>>['adapter']['getParent']} */
+  const getParent = (node) => {
+    if (!parents) {
+      parents = mapNodesToParents(relativeNode);
+    }
+
+    return parents.get(node) || null;
+  };
+
+  /**
+   * @param {any} elem
+   * @returns {any}
+   */
+  const getSiblings = (elem) => {
+    const parent = getParent(elem);
+    return parent ? getChildren(parent) : [];
+  };
+
+  /**
+   * @param {any} nodes
+   * @returns {any}
+   */
+  const removeSubsets = (nodes) => {
+    let idx = nodes.length;
+    let node;
+    let ancestor;
+    let replace;
+    // Check if each node (or one of its ancestors) is already contained in the
+    // array.
+    while (--idx > -1) {
+      node = ancestor = nodes[idx];
+      // Temporarily remove the node under consideration
+      nodes[idx] = null;
+      replace = true;
+      while (ancestor) {
+        if (nodes.includes(ancestor)) {
+          replace = false;
+          nodes.splice(idx, 1);
+          break;
+        }
+        ancestor = getParent(ancestor);
+      }
+      // If the node has been found to be unique, re-insert it.
+      if (replace) {
+        nodes[idx] = node;
+      }
+    }
+    return nodes;
+  };
 
-module.exports = svgoCssSelectAdapter;
+  return {
+    isTag,
+    existsOne,
+    getAttributeValue,
+    getChildren,
+    getName,
+    getParent,
+    getSiblings,
+    getText,
+    hasAttrib,
+    removeSubsets,
+    findAll,
+    findOne,
+  };
+}

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

@@ -1,18 +1,23 @@
-'use strict';
-
-const { visit } = require('../xast.js');
+import { visit } from '../util/visit.js';
 
 /**
  * Plugins engine.
  *
  * @module plugins
  *
- * @param {Object} ast input ast
- * @param {Object} info extra information
- * @param {Array} plugins plugins object from config
- * @return {Object} output ast
+ * @param {import('../types.js').XastNode} ast Input AST.
+ * @param {any} info Extra information.
+ * @param {ReadonlyArray<any>} plugins Plugins property from config.
+ * @param {any} overrides
+ * @param {any} globalOverrides
  */
-const invokePlugins = (ast, info, plugins, overrides, globalOverrides) => {
+export const invokePlugins = (
+  ast,
+  info,
+  plugins,
+  overrides,
+  globalOverrides,
+) => {
   for (const plugin of plugins) {
     const override = overrides?.[plugin.name];
     if (override === false) {
@@ -26,11 +31,17 @@ const invokePlugins = (ast, info, plugins, overrides, globalOverrides) => {
     }
   }
 };
-exports.invokePlugins = invokePlugins;
 
-const createPreset = ({ name, plugins }) => {
+/**
+ * @template {string} T
+ * @param {{ name: T, plugins: ReadonlyArray<import('../types.js').BuiltinPlugin<string, any>> }} arg0
+ * @returns {import('../types.js').BuiltinPluginOrPreset<T, any>}
+ */
+export const createPreset = ({ name, plugins }) => {
   return {
     name,
+    isPreset: true,
+    plugins: Object.freeze(plugins),
     fn: (ast, params, info) => {
       const { floatPrecision, overrides } = params;
       const globalOverrides = {};
@@ -58,4 +69,3 @@ const createPreset = ({ name, plugins }) => {
     },
   };
 };
-exports.createPreset = createPreset;

package/.output/server/node_modules/svgo/lib/svgo/tools.js

@@ -1,13 +1,12 @@
-'use strict';
+import { attrsGroups, referencesProps } from '../../plugins/_collections.js';
 
 /**
- * @typedef {import('../../lib/types').XastElement} XastElement
- * @typedef {import('../types').PathDataCommand} PathDataCommand
- * @typedef {import('../types').DataUri} DataUri
+ * @typedef CleanupOutDataParams
+ * @property {boolean=} noSpaceAfterFlags
+ * @property {boolean=} leadingZero
+ * @property {boolean=} negativeExtraSpace
  */
 
-const { attrsGroups, referencesProps } = require('../../plugins/_collections');
-
 const regReferencesUrl = /\burl\((["'])?#(.+?)\1\)/g;
 const regReferencesHref = /^#(.+?)$/;
 const regReferencesBegin = /(\w+)\.[a-zA-Z]/;
@@ -15,10 +14,12 @@ const regReferencesBegin = /(\w+)\.[a-zA-Z]/;
 /**
  * Encode plain SVG data string into Data URI string.
  *
- * @type {(str: string, type?: DataUri) => string}
+ * @param {string} str
+ * @param {import('../types.js').DataUri=} type
+ * @returns {string}
  */
-exports.encodeSVGDatauri = (str, type) => {
-  var prefix = 'data:image/svg+xml';
+export const encodeSVGDatauri = (str, type) => {
+  let prefix = 'data:image/svg+xml';
   if (!type || type === 'base64') {
     // base64
     prefix += ';base64,';
@@ -36,16 +37,19 @@ exports.encodeSVGDatauri = (str, type) => {
 /**
  * Decode SVG Data URI string into plain SVG string.
  *
- * @type {(str: string) => string}
+ * @param {string} str
+ * @returns {string}
  */
-exports.decodeSVGDatauri = (str) => {
-  var regexp = /data:image\/svg\+xml(;charset=[^;,]*)?(;base64)?,(.*)/;
-  var match = regexp.exec(str);
+export const decodeSVGDatauri = (str) => {
+  const regexp = /data:image\/svg\+xml(;charset=[^;,]*)?(;base64)?,(.*)/;
+  const match = regexp.exec(str);
 
   // plain string
-  if (!match) return str;
+  if (!match) {
+    return str;
+  }
 
-  var data = match[3];
+  const data = match[3];
 
   if (match[2]) {
     // base64
@@ -60,28 +64,21 @@ exports.decodeSVGDatauri = (str) => {
   return str;
 };
 
-/**
- * @typedef {{
- *   noSpaceAfterFlags?: boolean,
- *   leadingZero?: boolean,
- *   negativeExtraSpace?: boolean
- * }} CleanupOutDataParams
- */
-
 /**
  * Convert a row of numbers to an optimized string view.
  *
  * @example
  * [0, -1, .5, .5] → "0-1 .5.5"
  *
- * @type {(data: number[], params: CleanupOutDataParams, command?: PathDataCommand) => string}
+ * @param {ReadonlyArray<number>} data
+ * @param {CleanupOutDataParams} params
+ * @param {import('../types.js').PathDataCommand=} command
+ * @returns {string}
  */
-exports.cleanupOutData = (data, params, command) => {
+export const cleanupOutData = (data, params, command) => {
   let str = '';
   let delimiter;
-  /**
-   * @type {number}
-   */
+  /** @type {number} */
   let prev;
 
   data.forEach((item, i) => {
@@ -89,13 +86,17 @@ exports.cleanupOutData = (data, params, command) => {
     delimiter = ' ';
 
     // no extra space in front of first number
-    if (i == 0) delimiter = '';
+    if (i == 0) {
+      delimiter = '';
+    }
 
-    // no extra space after 'arcto' command flags(large-arc and sweep flags)
+    // no extra space after arc command flags (large-arc and sweep flags)
     // a20 60 45 0 1 30 20 → a20 60 45 0130 20
     if (params.noSpaceAfterFlags && (command == 'A' || command == 'a')) {
-      var pos = i % 7;
-      if (pos == 4 || pos == 5) delimiter = '';
+      const pos = i % 7;
+      if (pos == 4 || pos == 5) {
+        delimiter = '';
+      }
     }
 
     // remove floating-point numbers leading zeros
@@ -130,7 +131,7 @@ exports.cleanupOutData = (data, params, command) => {
  * 0.5 → .5
  * -0.5 → -.5
  */
-const removeLeadingZero = (value) => {
+export const removeLeadingZero = (value) => {
   const strValue = value.toString();
 
   if (0 < value && value < 1 && strValue.startsWith('0')) {
@@ -143,16 +144,15 @@ const removeLeadingZero = (value) => {
 
   return strValue;
 };
-exports.removeLeadingZero = removeLeadingZero;
 
 /**
  * If the current node contains any scripts. This does not check parents or
  * children of the node, only the properties and attributes of the node itself.
  *
- * @param {XastElement} node Current node to check against.
+ * @param {import('../types.js').XastElement} node Current node to check against.
  * @returns {boolean} If the current node contains scripts.
  */
-const hasScripts = (node) => {
+export const hasScripts = (node) => {
   if (node.name === 'script' && node.children.length !== 0) {
     return true;
   }
@@ -180,7 +180,6 @@ const hasScripts = (node) => {
 
   return eventAttrs.some((attr) => node.attributes[attr] != null);
 };
-exports.hasScripts = hasScripts;
 
 /**
  * For example, a string that contains one or more of following would match and
@@ -192,17 +191,16 @@ exports.hasScripts = hasScripts;
  * @param {string} body
  * @returns {boolean} If the given string includes a URL reference.
  */
-const includesUrlReference = (body) => {
+export const includesUrlReference = (body) => {
   return new RegExp(regReferencesUrl).test(body);
 };
-exports.includesUrlReference = includesUrlReference;
 
 /**
  * @param {string} attribute
  * @param {string} value
  * @returns {string[]}
  */
-const findReferences = (attribute, value) => {
+export const findReferences = (attribute, value) => {
   const results = [];
 
   if (referencesProps.has(attribute)) {
@@ -228,7 +226,6 @@ const findReferences = (attribute, value) => {
 
   return results.map((body) => decodeURI(body));
 };
-exports.findReferences = findReferences;
 
 /**
  * Does the same as {@link Number.toFixed} but without casting
@@ -238,8 +235,7 @@ exports.findReferences = findReferences;
  * @param {number} precision
  * @returns {number}
  */
-const toFixed = (num, precision) => {
+export const toFixed = (num, precision) => {
   const pow = 10 ** precision;
   return Math.round(num * pow) / pow;
 };
-exports.toFixed = toFixed;