inital commit

node_modules/@next/eslint-plugin-next/dist/rules/google-font-display.js

@@ -0,0 +1,51 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var _nodeattributes = /*#__PURE__*/ _interop_require_default(require("../utils/node-attributes"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var url = 'https://nextjs.org/docs/messages/google-font-display';
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Enforce font-display behavior with Google Fonts.',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        return {
+            JSXOpeningElement: function JSXOpeningElement(node) {
+                var message;
+                if (node.name.name !== 'link') {
+                    return;
+                }
+                var attributes = new _nodeattributes.default(node);
+                if (!attributes.has('href') || !attributes.hasValue('href')) {
+                    return;
+                }
+                var hrefValue = attributes.value('href');
+                var isGoogleFont = typeof hrefValue === 'string' && hrefValue.startsWith('https://fonts.googleapis.com/css');
+                if (isGoogleFont) {
+                    var params = new URLSearchParams(hrefValue.split('?', 2)[1]);
+                    var displayValue = params.get('display');
+                    if (!params.has('display')) {
+                        message = 'A font-display parameter is missing (adding `&display=optional` is recommended).';
+                    } else if (displayValue === 'auto' || displayValue === 'block' || displayValue === 'fallback') {
+                        message = "".concat(displayValue[0].toUpperCase() + displayValue.slice(1), " is not recommended.");
+                    }
+                }
+                if (message) {
+                    context.report({
+                        node: node,
+                        message: "".concat(message, " See: ").concat(url)
+                    });
+                }
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/google-font-preconnect.js

@@ -0,0 +1,41 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var _nodeattributes = /*#__PURE__*/ _interop_require_default(require("../utils/node-attributes"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var url = 'https://nextjs.org/docs/messages/google-font-preconnect';
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Ensure `preconnect` is used with Google Fonts.',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        return {
+            JSXOpeningElement: function JSXOpeningElement(node) {
+                if (node.name.name !== 'link') {
+                    return;
+                }
+                var attributes = new _nodeattributes.default(node);
+                if (!attributes.has('href') || !attributes.hasValue('href')) {
+                    return;
+                }
+                var hrefValue = attributes.value('href');
+                var preconnectMissing = !attributes.has('rel') || !attributes.hasValue('rel') || attributes.value('rel') !== 'preconnect';
+                if (typeof hrefValue === 'string' && hrefValue.startsWith('https://fonts.gstatic.com') && preconnectMissing) {
+                    context.report({
+                        node: node,
+                        message: '`rel="preconnect"` is missing from Google Font. See: '.concat(url)
+                    });
+                }
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/inline-script-id.js

@@ -0,0 +1,59 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var url = 'https://nextjs.org/docs/messages/inline-script-id';
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Enforce `id` attribute on `next/script` components with inline content.',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        var nextScriptImportName = null;
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                if (node.source.value === 'next/script') {
+                    nextScriptImportName = node.specifiers[0].local.name;
+                }
+            },
+            JSXElement: function JSXElement(node) {
+                if (nextScriptImportName == null) return;
+                if (node.openingElement && node.openingElement.name && node.openingElement.name.name !== nextScriptImportName) {
+                    return;
+                }
+                var attributeNames = new Set();
+                var hasNonCheckableSpreadAttribute = false;
+                node.openingElement.attributes.forEach(function(attribute) {
+                    // Early return if we already have a non-checkable spread attribute, for better performance
+                    if (hasNonCheckableSpreadAttribute) return;
+                    if (attribute.type === 'JSXAttribute') {
+                        attributeNames.add(attribute.name.name);
+                    } else if (attribute.type === 'JSXSpreadAttribute') {
+                        if (attribute.argument && attribute.argument.properties) {
+                            attribute.argument.properties.forEach(function(property) {
+                                attributeNames.add(property.key.name);
+                            });
+                        } else {
+                            // JSXSpreadAttribute without properties is not checkable
+                            hasNonCheckableSpreadAttribute = true;
+                        }
+                    }
+                });
+                // https://github.com/vercel/next.js/issues/34030
+                // If there is a non-checkable spread attribute, we simply ignore them
+                if (hasNonCheckableSpreadAttribute) return;
+                if (node.children.length > 0 || attributeNames.has('dangerouslySetInnerHTML')) {
+                    if (!attributeNames.has('id')) {
+                        context.report({
+                            node: node,
+                            message: "`next/script` components with inline content must specify an `id` attribute. See: ".concat(url)
+                        });
+                    }
+                }
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/next-script-for-ga.js

@@ -0,0 +1,70 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var _nodeattributes = /*#__PURE__*/ _interop_require_default(require("../utils/node-attributes"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var SUPPORTED_SRCS = [
+    'www.google-analytics.com/analytics.js',
+    'www.googletagmanager.com/gtag/js'
+];
+var SUPPORTED_HTML_CONTENT_URLS = [
+    'www.google-analytics.com/analytics.js',
+    'www.googletagmanager.com/gtm.js'
+];
+var description = 'Prefer `next/script` component when using the inline script for Google Analytics.';
+var url = 'https://nextjs.org/docs/messages/next-script-for-ga';
+var ERROR_MSG = "".concat(description, " See: ").concat(url);
+// Check if one of the items in the list is a substring of the passed string
+var containsStr = function(str, strList) {
+    return strList.some(function(s) {
+        return str.includes(s);
+    });
+};
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: description,
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        return {
+            JSXOpeningElement: function JSXOpeningElement(node) {
+                if (node.name.name !== 'script') {
+                    return;
+                }
+                if (node.attributes.length === 0) {
+                    return;
+                }
+                var attributes = new _nodeattributes.default(node);
+                // Check if the Alternative async tag is being used to add GA.
+                // https://developers.google.com/analytics/devguides/collection/analyticsjs#alternative_async_tag
+                // https://developers.google.com/analytics/devguides/collection/gtagjs
+                if (typeof attributes.value('src') === 'string' && containsStr(attributes.value('src'), SUPPORTED_SRCS)) {
+                    return context.report({
+                        node: node,
+                        message: ERROR_MSG
+                    });
+                }
+                // Check if inline script is being used to add GA.
+                // https://developers.google.com/analytics/devguides/collection/analyticsjs#the_google_analytics_tag
+                // https://developers.google.com/tag-manager/quickstart
+                if (attributes.value('dangerouslySetInnerHTML') && attributes.value('dangerouslySetInnerHTML').length > 0) {
+                    var htmlContent = attributes.value('dangerouslySetInnerHTML')[0].value.quasis && attributes.value('dangerouslySetInnerHTML')[0].value.quasis[0].value.raw;
+                    if (htmlContent && containsStr(htmlContent, SUPPORTED_HTML_CONTENT_URLS)) {
+                        context.report({
+                            node: node,
+                            message: ERROR_MSG
+                        });
+                    }
+                }
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-assign-module-variable.js

@@ -0,0 +1,35 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var url = 'https://nextjs.org/docs/messages/no-assign-module-variable';
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Prevent assignment to the `module` variable.',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        return {
+            VariableDeclaration: function VariableDeclaration(node) {
+                // Checks node.declarations array for variable with id.name of `module`
+                var moduleVariableFound = node.declarations.some(function(declaration) {
+                    if ('name' in declaration.id) {
+                        return declaration.id.name === 'module';
+                    }
+                    return false;
+                });
+                // Return early if no `module` variable is found
+                if (!moduleVariableFound) {
+                    return;
+                }
+                context.report({
+                    node: node,
+                    message: "Do not assign to the variable `module`. See: ".concat(url)
+                });
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-async-client-component.js

@@ -0,0 +1,90 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var url = 'https://nextjs.org/docs/messages/no-async-client-component';
+var description = 'Prevent client components from being async functions.';
+var message = "".concat(description, " See: ").concat(url);
+function isCapitalized(str) {
+    return /[A-Z]/.test(str === null || str === void 0 ? void 0 : str[0]);
+}
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: description,
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        return {
+            Program: function Program(node) {
+                var isClientComponent = false;
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    var _loop = function() {
+                        var block = _step.value;
+                        if (block.type === 'ExpressionStatement' && block.expression.type === 'Literal' && block.expression.value === 'use client') {
+                            isClientComponent = true;
+                        }
+                        if (block.type === 'ExportDefaultDeclaration' && isClientComponent) {
+                            var _block_declaration;
+                            // export default async function MyComponent() {...}
+                            if (((_block_declaration = block.declaration) === null || _block_declaration === void 0 ? void 0 : _block_declaration.type) === 'FunctionDeclaration' && block.declaration.async && isCapitalized(block.declaration.id.name)) {
+                                context.report({
+                                    node: block,
+                                    message: message
+                                });
+                            }
+                            // async function MyComponent() {...}; export default MyComponent;
+                            if (block.declaration.type === 'Identifier' && isCapitalized(block.declaration.name)) {
+                                var targetName = block.declaration.name;
+                                var functionDeclaration = node.body.find(function(localBlock) {
+                                    if (localBlock.type === 'FunctionDeclaration' && localBlock.id.name === targetName) return true;
+                                    if (localBlock.type === 'VariableDeclaration' && localBlock.declarations.find(function(declaration) {
+                                        var _declaration_id;
+                                        return ((_declaration_id = declaration.id) === null || _declaration_id === void 0 ? void 0 : _declaration_id.type) === 'Identifier' && declaration.id.name === targetName;
+                                    })) return true;
+                                    return false;
+                                });
+                                if ((functionDeclaration === null || functionDeclaration === void 0 ? void 0 : functionDeclaration.type) === 'FunctionDeclaration' && functionDeclaration.async) {
+                                    context.report({
+                                        node: functionDeclaration,
+                                        message: message
+                                    });
+                                }
+                                if ((functionDeclaration === null || functionDeclaration === void 0 ? void 0 : functionDeclaration.type) === 'VariableDeclaration') {
+                                    var _varDeclarator_init;
+                                    var varDeclarator = functionDeclaration.declarations.find(function(declaration) {
+                                        var _declaration_id;
+                                        return ((_declaration_id = declaration.id) === null || _declaration_id === void 0 ? void 0 : _declaration_id.type) === 'Identifier' && declaration.id.name === targetName;
+                                    });
+                                    if ((varDeclarator === null || varDeclarator === void 0 ? void 0 : (_varDeclarator_init = varDeclarator.init) === null || _varDeclarator_init === void 0 ? void 0 : _varDeclarator_init.type) === 'ArrowFunctionExpression' && varDeclarator.init.async) {
+                                        context.report({
+                                            node: functionDeclaration,
+                                            message: message
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    };
+                    for(var _iterator = node.body[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-before-interactive-script-outside-document.js

@@ -0,0 +1,95 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var url = 'https://nextjs.org/docs/messages/no-before-interactive-script-outside-document';
+var convertToCorrectSeparator = function(str) {
+    return str.replace(/[\\/]/g, _path.sep);
+};
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: "Prevent usage of `next/script`'s `beforeInteractive` strategy outside of `pages/_document.js`.",
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        var scriptImportName = null;
+        return {
+            'ImportDeclaration[source.value="next/script"] > ImportDefaultSpecifier': function(node) {
+                scriptImportName = node.local.name;
+            },
+            JSXOpeningElement: function JSXOpeningElement(node) {
+                var pathname = convertToCorrectSeparator(context.filename);
+                var isInAppDir = pathname.includes("".concat(_path.sep, "app").concat(_path.sep));
+                // This rule shouldn't fire in `app/`
+                if (isInAppDir) {
+                    return;
+                }
+                if (!scriptImportName) {
+                    return;
+                }
+                if (node.name && node.name.name !== scriptImportName) {
+                    return;
+                }
+                var strategy = node.attributes.find(function(child) {
+                    return child.name && child.name.name === 'strategy';
+                });
+                if (!strategy || !strategy.value || strategy.value.value !== 'beforeInteractive') {
+                    return;
+                }
+                var document = context.filename.split('pages', 2)[1];
+                if (document && _path.parse(document).name.startsWith('_document')) {
+                    return;
+                }
+                context.report({
+                    node: node,
+                    message: "`next/script`'s `beforeInteractive` strategy should not be used outside of `pages/_document.js`. See: ".concat(url)
+                });
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-css-tags.js

@@ -0,0 +1,39 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var url = 'https://nextjs.org/docs/messages/no-css-tags';
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Prevent manual stylesheet tags.',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        return {
+            JSXOpeningElement: function JSXOpeningElement(node) {
+                if (node.name.name !== 'link') {
+                    return;
+                }
+                if (node.attributes.length === 0) {
+                    return;
+                }
+                var attributes = node.attributes.filter(function(attr) {
+                    return attr.type === 'JSXAttribute';
+                });
+                if (attributes.find(function(attr) {
+                    return attr.name.name === 'rel' && attr.value.value === 'stylesheet';
+                }) && attributes.find(function(attr) {
+                    return attr.name.name === 'href' && attr.value.type === 'Literal' && !/^https?/.test(attr.value.value);
+                })) {
+                    context.report({
+                        node: node,
+                        message: "Do not include stylesheets manually. See: ".concat(url)
+                    });
+                }
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-document-import-in-page.js

@@ -0,0 +1,74 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var url = 'https://nextjs.org/docs/messages/no-document-import-in-page';
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Prevent importing `next/document` outside of `pages/_document.js`.',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                if (node.source.value !== 'next/document') {
+                    return;
+                }
+                var paths = context.filename.split('pages');
+                var page = paths[paths.length - 1];
+                if (!page || page.startsWith("".concat(_path.sep, "_document")) || page.startsWith("".concat(_path.posix.sep, "_document"))) {
+                    return;
+                }
+                context.report({
+                    node: node,
+                    message: "`<Document />` from `next/document` should not be imported outside of `pages/_document.js`. See: ".concat(url)
+                });
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-duplicate-head.js

@@ -0,0 +1,54 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var url = 'https://nextjs.org/docs/messages/no-duplicate-head';
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Prevent duplicate usage of `<Head>` in `pages/_document.js`.',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        var sourceCode = context.sourceCode;
+        var documentImportName;
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                if (node.source.value === 'next/document') {
+                    var documentImport = node.specifiers.find(function(param) {
+                        var type = param.type;
+                        return type === 'ImportDefaultSpecifier';
+                    });
+                    if (documentImport && documentImport.local) {
+                        documentImportName = documentImport.local.name;
+                    }
+                }
+            },
+            ReturnStatement: function ReturnStatement(node) {
+                var ancestors = sourceCode.getAncestors(node);
+                var documentClass = ancestors.find(function(ancestorNode) {
+                    return ancestorNode.type === 'ClassDeclaration' && ancestorNode.superClass && 'name' in ancestorNode.superClass && ancestorNode.superClass.name === documentImportName;
+                });
+                if (!documentClass) {
+                    return;
+                }
+                if (node.argument && 'children' in node.argument && node.argument.children) {
+                    // @ts-expect-error - `node.argument` could be a `JSXElement` which has property `children`
+                    var headComponents = node.argument.children.filter(function(childrenNode) {
+                        return childrenNode.openingElement && childrenNode.openingElement.name && childrenNode.openingElement.name.name === 'Head';
+                    });
+                    if (headComponents.length > 1) {
+                        for(var i = 1; i < headComponents.length; i++){
+                            context.report({
+                                node: headComponents[i],
+                                message: "Do not include multiple instances of `<Head/>`. See: ".concat(url)
+                            });
+                        }
+                    }
+                }
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-head-element.js

@@ -0,0 +1,34 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var path = require("path");
+var url = 'https://nextjs.org/docs/messages/no-head-element';
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Prevent usage of `<head>` element.',
+            category: 'HTML',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        return {
+            JSXOpeningElement: function JSXOpeningElement(node) {
+                var paths = context.filename;
+                var isInAppDir = function() {
+                    return paths.includes("app".concat(path.sep)) || paths.includes("app".concat(path.posix.sep));
+                };
+                // Only lint the <head> element in pages directory
+                if (node.name.name !== 'head' || isInAppDir()) {
+                    return;
+                }
+                context.report({
+                    node: node,
+                    message: "Do not use `<head>` element. Use `<Head />` from `next/head` instead. See: ".concat(url)
+                });
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-head-import-in-document.js

@@ -0,0 +1,76 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var url = 'https://nextjs.org/docs/messages/no-head-import-in-document';
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Prevent usage of `next/head` in `pages/_document.js`.',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                if (node.source.value !== 'next/head') {
+                    return;
+                }
+                var document = context.filename.split('pages', 2)[1];
+                if (!document) {
+                    return;
+                }
+                var _path_parse = _path.parse(document), name = _path_parse.name, dir = _path_parse.dir;
+                if (name.startsWith('_document') || dir === '/_document' && name === 'index') {
+                    context.report({
+                        node: node,
+                        message: "`next/head` should not be imported in `pages".concat(document, "`. Use `<Head />` from `next/document` instead. See: ").concat(url)
+                    });
+                }
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-html-link-for-pages.js

@@ -0,0 +1,236 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+var _fs = /*#__PURE__*/ _interop_require_wildcard(require("fs"));
+var _getrootdirs = require("../utils/get-root-dirs");
+var _url = require("../utils/url");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var pagesDirWarning = (0, _url.execOnce)(function(pagesDirs) {
+    console.warn("Pages directory cannot be found at ".concat(pagesDirs.join(' or '), ". ") + 'If using a custom path, please configure with the `no-html-link-for-pages` rule in your eslint config file.');
+});
+// Cache for fs.existsSync lookup.
+// Prevent multiple blocking IO requests that have already been calculated.
+var fsExistsSyncCache = {};
+var memoize = function(fn) {
+    var cache = {};
+    return function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        var key = JSON.stringify(args);
+        if (cache[key] === undefined) {
+            cache[key] = fn.apply(void 0, _to_consumable_array(args));
+        }
+        return cache[key];
+    };
+};
+var cachedGetUrlFromPagesDirectories = memoize(_url.getUrlFromPagesDirectories);
+var cachedGetUrlFromAppDirectory = memoize(_url.getUrlFromAppDirectory);
+var url = 'https://nextjs.org/docs/messages/no-html-link-for-pages';
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Prevent usage of `<a>` elements to navigate to internal Next.js pages.',
+            category: 'HTML',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: [
+            {
+                oneOf: [
+                    {
+                        type: 'string'
+                    },
+                    {
+                        type: 'array',
+                        uniqueItems: true,
+                        items: {
+                            type: 'string'
+                        }
+                    }
+                ]
+            }
+        ]
+    },
+    /**
+   * Creates an ESLint rule listener.
+   */ create: function create(context) {
+        var ruleOptions = context.options;
+        var _ruleOptions = _sliced_to_array(ruleOptions, 1), customPagesDirectory = _ruleOptions[0];
+        var rootDirs = (0, _getrootdirs.getRootDirs)(context);
+        var pagesDirs = (customPagesDirectory ? [
+            customPagesDirectory
+        ] : rootDirs.map(function(dir) {
+            return [
+                _path.join(dir, 'pages'),
+                _path.join(dir, 'src', 'pages')
+            ];
+        })).flat();
+        var foundPagesDirs = pagesDirs.filter(function(dir) {
+            if (fsExistsSyncCache[dir] === undefined) {
+                fsExistsSyncCache[dir] = _fs.existsSync(dir);
+            }
+            return fsExistsSyncCache[dir];
+        });
+        var appDirs = rootDirs.map(function(dir) {
+            return [
+                _path.join(dir, 'app'),
+                _path.join(dir, 'src', 'app')
+            ];
+        }).flat();
+        var foundAppDirs = appDirs.filter(function(dir) {
+            if (fsExistsSyncCache[dir] === undefined) {
+                fsExistsSyncCache[dir] = _fs.existsSync(dir);
+            }
+            return fsExistsSyncCache[dir];
+        });
+        // warn if there are no pages and app directories
+        if (foundPagesDirs.length === 0 && foundAppDirs.length === 0) {
+            pagesDirWarning(pagesDirs);
+            return {};
+        }
+        var pageUrls = cachedGetUrlFromPagesDirectories('/', foundPagesDirs);
+        var appDirUrls = cachedGetUrlFromAppDirectory('/', foundAppDirs);
+        var allUrlRegex = _to_consumable_array(pageUrls).concat(_to_consumable_array(appDirUrls));
+        return {
+            JSXOpeningElement: function JSXOpeningElement(node) {
+                if (node.name.name !== 'a') {
+                    return;
+                }
+                if (node.attributes.length === 0) {
+                    return;
+                }
+                var target = node.attributes.find(function(attr) {
+                    return attr.type === 'JSXAttribute' && attr.name.name === 'target';
+                });
+                if (target && target.value.value === '_blank') {
+                    return;
+                }
+                var href = node.attributes.find(function(attr) {
+                    return attr.type === 'JSXAttribute' && attr.name.name === 'href';
+                });
+                if (!href || href.value && href.value.type !== 'Literal') {
+                    return;
+                }
+                var hasDownloadAttr = node.attributes.find(function(attr) {
+                    return attr.type === 'JSXAttribute' && attr.name.name === 'download';
+                });
+                if (hasDownloadAttr) {
+                    return;
+                }
+                var hrefPath = (0, _url.normalizeURL)(href.value.value);
+                // Outgoing links are ignored
+                if (/^(https?:\/\/|\/\/)/.test(hrefPath)) {
+                    return;
+                }
+                allUrlRegex.forEach(function(foundUrl) {
+                    if (foundUrl.test((0, _url.normalizeURL)(hrefPath))) {
+                        context.report({
+                            node: node,
+                            message: "Do not use an `<a>` element to navigate to `".concat(hrefPath, "`. Use `<Link />` from `next/link` instead. See: ").concat(url)
+                        });
+                    }
+                });
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-img-element.js

@@ -0,0 +1,42 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var path = require("path");
+var url = 'https://nextjs.org/docs/messages/no-img-element';
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Prevent usage of `<img>` element due to slower LCP and higher bandwidth.',
+            category: 'HTML',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        // Get relative path of the file
+        var relativePath = context.filename.replace(path.sep, '/').replace(context.cwd, '').replace(/^\//, '');
+        var isAppDir = /^(src\/)?app\//.test(relativePath);
+        return {
+            JSXOpeningElement: function JSXOpeningElement(node) {
+                var _node_parent_parent_openingElement_name, _node_parent_parent_openingElement, _node_parent_parent, _node_parent;
+                if (node.name.name !== 'img') {
+                    return;
+                }
+                if (node.attributes.length === 0) {
+                    return;
+                }
+                if (((_node_parent = node.parent) === null || _node_parent === void 0 ? void 0 : (_node_parent_parent = _node_parent.parent) === null || _node_parent_parent === void 0 ? void 0 : (_node_parent_parent_openingElement = _node_parent_parent.openingElement) === null || _node_parent_parent_openingElement === void 0 ? void 0 : (_node_parent_parent_openingElement_name = _node_parent_parent_openingElement.name) === null || _node_parent_parent_openingElement_name === void 0 ? void 0 : _node_parent_parent_openingElement_name.name) === 'picture') {
+                    return;
+                }
+                // If is metadata route files, ignore
+                // e.g. opengraph-image.js, twitter-image.js, icon.js
+                if (isAppDir && /\/opengraph-image|twitter-image|icon\.\w+$/.test(relativePath)) return;
+                context.report({
+                    node: node,
+                    message: "Using `<img>` could result in slower LCP and higher bandwidth. Consider using `<Image />` from `next/image` or a custom image loader to automatically optimize images. This may incur additional usage or cost from your provider. See: ".concat(url)
+                });
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-page-custom-font.js

@@ -0,0 +1,127 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var _nodeattributes = /*#__PURE__*/ _interop_require_default(require("../utils/node-attributes"));
+var _path = require("path");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var url = 'https://nextjs.org/docs/messages/no-page-custom-font';
+function isIdentifierMatch(id1, id2) {
+    return id1 === null && id2 === null || id1 && id2 && id1.name === id2.name;
+}
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Prevent page-only custom fonts.',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        var sourceCode = context.sourceCode;
+        var paths = context.filename.split('pages');
+        var page = paths[paths.length - 1];
+        // outside of a file within `pages`, bail
+        if (!page) {
+            return {};
+        }
+        var is_Document = page.startsWith("".concat(_path.sep, "_document")) || page.startsWith("".concat(_path.posix.sep, "_document"));
+        var documentImportName;
+        var localDefaultExportId;
+        var exportDeclarationType;
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                if (node.source.value === 'next/document') {
+                    var documentImport = node.specifiers.find(function(param) {
+                        var type = param.type;
+                        return type === 'ImportDefaultSpecifier';
+                    });
+                    if (documentImport && documentImport.local) {
+                        documentImportName = documentImport.local.name;
+                    }
+                }
+            },
+            ExportDefaultDeclaration: function ExportDefaultDeclaration(node) {
+                exportDeclarationType = node.declaration.type;
+                if (node.declaration.type === 'FunctionDeclaration') {
+                    localDefaultExportId = node.declaration.id;
+                    return;
+                }
+                if (node.declaration.type === 'ClassDeclaration' && node.declaration.superClass && 'name' in node.declaration.superClass && node.declaration.superClass.name === documentImportName) {
+                    localDefaultExportId = node.declaration.id;
+                }
+            },
+            JSXOpeningElement: function JSXOpeningElement(node) {
+                if (node.name.name !== 'link') {
+                    return;
+                }
+                var ancestors = sourceCode.getAncestors(node);
+                // if `export default <name>` is further down within the file after the
+                // currently traversed component, then `localDefaultExportName` will
+                // still be undefined
+                if (!localDefaultExportId) {
+                    // find the top level of the module
+                    var program = ancestors.find(function(ancestor) {
+                        return ancestor.type === 'Program';
+                    });
+                    // go over each token to find the combination of `export default <name>`
+                    for(var i = 0; i <= program.tokens.length - 1; i++){
+                        if (localDefaultExportId) {
+                            break;
+                        }
+                        var token = program.tokens[i];
+                        if (token.type === 'Keyword' && token.value === 'export') {
+                            var nextToken = program.tokens[i + 1];
+                            if (nextToken && nextToken.type === 'Keyword' && nextToken.value === 'default') {
+                                var maybeIdentifier = program.tokens[i + 2];
+                                if (maybeIdentifier && maybeIdentifier.type === 'Identifier') {
+                                    localDefaultExportId = {
+                                        name: maybeIdentifier.value
+                                    };
+                                }
+                            }
+                        }
+                    }
+                }
+                var parentComponent = ancestors.find(function(ancestor) {
+                    // export default class ... extends ...
+                    if (exportDeclarationType === 'ClassDeclaration') {
+                        return ancestor.type === exportDeclarationType && 'superClass' in ancestor && ancestor.superClass && 'name' in ancestor.superClass && ancestor.superClass.name === documentImportName;
+                    }
+                    if ('id' in ancestor) {
+                        // export default function ...
+                        if (exportDeclarationType === 'FunctionDeclaration') {
+                            return ancestor.type === exportDeclarationType && isIdentifierMatch(ancestor.id, localDefaultExportId);
+                        }
+                        // function ...() {} export default ...
+                        // class ... extends ...; export default ...
+                        return isIdentifierMatch(ancestor.id, localDefaultExportId);
+                    }
+                    return false;
+                });
+                // file starts with _document and this <link /> is within the default export
+                if (is_Document && parentComponent) {
+                    return;
+                }
+                var attributes = new _nodeattributes.default(node);
+                if (!attributes.has('href') || !attributes.hasValue('href')) {
+                    return;
+                }
+                var hrefValue = attributes.value('href');
+                var isGoogleFont = typeof hrefValue === 'string' && hrefValue.startsWith('https://fonts.googleapis.com/css');
+                if (isGoogleFont) {
+                    var end = "This is discouraged. See: ".concat(url);
+                    var message = is_Document ? "Using `<link />` outside of `<Head>` will disable automatic font optimization. ".concat(end) : "Custom fonts not added in `pages/_document.js` will only load for a single page. ".concat(end);
+                    context.report({
+                        node: node,
+                        message: message
+                    });
+                }
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-script-component-in-head.js

@@ -0,0 +1,44 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var url = 'https://nextjs.org/docs/messages/no-script-component-in-head';
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Prevent usage of `next/script` in `next/head` component.',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        var isNextHead = null;
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                if (node.source.value === 'next/head') {
+                    isNextHead = node.source.value;
+                }
+                if (node.source.value !== 'next/script') {
+                    return;
+                }
+            },
+            JSXElement: function JSXElement(node) {
+                if (!isNextHead) {
+                    return;
+                }
+                if (node.openingElement && node.openingElement.name && node.openingElement.name.name !== 'Head') {
+                    return;
+                }
+                var scriptTag = node.children.find(function(child) {
+                    return child.openingElement && child.openingElement.name && child.openingElement.name.name === 'Script';
+                });
+                if (scriptTag) {
+                    context.report({
+                        node: node,
+                        message: "`next/script` should not be used in `next/head` component. Move `<Script />` outside of `<Head>` instead. See: ".concat(url)
+                    });
+                }
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-styled-jsx-in-document.js

@@ -0,0 +1,78 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var url = 'https://nextjs.org/docs/messages/no-styled-jsx-in-document';
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Prevent usage of `styled-jsx` in `pages/_document.js`.',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        return {
+            JSXOpeningElement: function JSXOpeningElement(node) {
+                var document = context.filename.split('pages', 2)[1];
+                if (!document) {
+                    return;
+                }
+                var _path_parse = _path.parse(document), name = _path_parse.name, dir = _path_parse.dir;
+                if (!(name.startsWith('_document') || dir === '/_document' && name === 'index')) {
+                    return;
+                }
+                if (node.name.name === 'style' && node.attributes.find(function(attr) {
+                    return attr.type === 'JSXAttribute' && attr.name.name === 'jsx';
+                })) {
+                    context.report({
+                        node: node,
+                        message: "`styled-jsx` should not be used in `pages/_document.js`. See: ".concat(url)
+                    });
+                }
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-sync-scripts.js

@@ -0,0 +1,37 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var url = 'https://nextjs.org/docs/messages/no-sync-scripts';
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Prevent synchronous scripts.',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        return {
+            JSXOpeningElement: function JSXOpeningElement(node) {
+                if (node.name.name !== 'script') {
+                    return;
+                }
+                if (node.attributes.length === 0) {
+                    return;
+                }
+                var attributeNames = node.attributes.filter(function(attr) {
+                    return attr.type === 'JSXAttribute';
+                }).map(function(attr) {
+                    return attr.name.name;
+                });
+                if (attributeNames.includes('src') && !attributeNames.includes('async') && !attributeNames.includes('defer')) {
+                    context.report({
+                        node: node,
+                        message: "Synchronous scripts should not be used. See: ".concat(url)
+                    });
+                }
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-title-in-document-head.js

@@ -0,0 +1,46 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var url = 'https://nextjs.org/docs/messages/no-title-in-document-head';
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Prevent usage of `<title>` with `Head` component from `next/document`.',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        var headFromNextDocument = false;
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                if (node.source.value === 'next/document') {
+                    if (node.specifiers.some(function(param) {
+                        var local = param.local;
+                        return local.name === 'Head';
+                    })) {
+                        headFromNextDocument = true;
+                    }
+                }
+            },
+            JSXElement: function JSXElement(node) {
+                if (!headFromNextDocument) {
+                    return;
+                }
+                if (node.openingElement && node.openingElement.name && node.openingElement.name.name !== 'Head') {
+                    return;
+                }
+                var titleTag = node.children.find(function(child) {
+                    return child.openingElement && child.openingElement.name && child.openingElement.name.type === 'JSXIdentifier' && child.openingElement.name.name === 'title';
+                });
+                if (titleTag) {
+                    context.report({
+                        node: titleTag,
+                        message: "Do not use `<title>` element with `<Head />` component from `next/document`. Titles should defined at the page-level using `<Head />` from `next/head` instead. See: ".concat(url)
+                    });
+                }
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-typos.js

@@ -0,0 +1,150 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+var _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var NEXT_EXPORT_FUNCTIONS = [
+    'getStaticProps',
+    'getStaticPaths',
+    'getServerSideProps'
+];
+// 0 is the exact match
+var THRESHOLD = 1;
+// the minimum number of operations required to convert string a to string b.
+function minDistance(a, b) {
+    var m = a.length;
+    var n = b.length;
+    if (m < n) {
+        return minDistance(b, a);
+    }
+    if (n === 0) {
+        return m;
+    }
+    var previousRow = Array.from({
+        length: n + 1
+    }, function(_, i) {
+        return i;
+    });
+    for(var i = 0; i < m; i++){
+        var s1 = a[i];
+        var currentRow = [
+            i + 1
+        ];
+        for(var j = 0; j < n; j++){
+            var s2 = b[j];
+            var insertions = previousRow[j + 1] + 1;
+            var deletions = currentRow[j] + 1;
+            var substitutions = previousRow[j] + Number(s1 !== s2);
+            currentRow.push(Math.min(insertions, deletions, substitutions));
+        }
+        previousRow = currentRow;
+    }
+    return previousRow[previousRow.length - 1];
+}
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Prevent common typos in Next.js data fetching functions.',
+            recommended: true
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        function checkTypos(node, name) {
+            if (NEXT_EXPORT_FUNCTIONS.includes(name)) {
+                return;
+            }
+            var potentialTypos = NEXT_EXPORT_FUNCTIONS.map(function(o) {
+                return {
+                    option: o,
+                    distance: minDistance(o, name)
+                };
+            }).filter(function(param) {
+                var distance = param.distance;
+                return distance <= THRESHOLD && distance > 0;
+            }).sort(function(a, b) {
+                return a.distance - b.distance;
+            });
+            if (potentialTypos.length) {
+                context.report({
+                    node: node,
+                    message: "".concat(name, " may be a typo. Did you mean ").concat(potentialTypos[0].option, "?")
+                });
+            }
+        }
+        return {
+            ExportNamedDeclaration: function ExportNamedDeclaration(node) {
+                var page = context.filename.split('pages', 2)[1];
+                if (!page || _path.parse(page).dir.startsWith('/api')) {
+                    return;
+                }
+                var decl = node.declaration;
+                if (!decl) {
+                    return;
+                }
+                switch(decl.type){
+                    case 'FunctionDeclaration':
+                        {
+                            checkTypos(node, decl.id.name);
+                            break;
+                        }
+                    case 'VariableDeclaration':
+                        {
+                            decl.declarations.forEach(function(d) {
+                                if (d.id.type !== 'Identifier') {
+                                    return;
+                                }
+                                checkTypos(node, d.id.name);
+                            });
+                            break;
+                        }
+                    default:
+                        {
+                            break;
+                        }
+                }
+                return;
+            }
+        };
+    }
+});

node_modules/@next/eslint-plugin-next/dist/rules/no-unwanted-polyfillio.js

@@ -0,0 +1,122 @@
+"use strict";
+var _definerule = require("../utils/define-rule");
+// Keep in sync with next.js polyfills file : https://github.com/vercel/next.js/blob/master/packages/next-polyfill-nomodule/src/index.js
+var NEXT_POLYFILLED_FEATURES = [
+    'Array.prototype.@@iterator',
+    'Array.prototype.at',
+    'Array.prototype.copyWithin',
+    'Array.prototype.fill',
+    'Array.prototype.find',
+    'Array.prototype.findIndex',
+    'Array.prototype.flatMap',
+    'Array.prototype.flat',
+    'Array.from',
+    'Array.prototype.includes',
+    'Array.of',
+    'Function.prototype.name',
+    'fetch',
+    'Map',
+    'Number.EPSILON',
+    'Number.Epsilon',
+    'Number.isFinite',
+    'Number.isNaN',
+    'Number.isInteger',
+    'Number.isSafeInteger',
+    'Number.MAX_SAFE_INTEGER',
+    'Number.MIN_SAFE_INTEGER',
+    'Number.parseFloat',
+    'Number.parseInt',
+    'Object.assign',
+    'Object.entries',
+    'Object.fromEntries',
+    'Object.getOwnPropertyDescriptor',
+    'Object.getOwnPropertyDescriptors',
+    'Object.hasOwn',
+    'Object.is',
+    'Object.keys',
+    'Object.values',
+    'Reflect',
+    'Set',
+    'Symbol',
+    'Symbol.asyncIterator',
+    'String.prototype.codePointAt',
+    'String.prototype.endsWith',
+    'String.fromCodePoint',
+    'String.prototype.includes',
+    'String.prototype.@@iterator',
+    'String.prototype.padEnd',
+    'String.prototype.padStart',
+    'String.prototype.repeat',
+    'String.raw',
+    'String.prototype.startsWith',
+    'String.prototype.trimEnd',
+    'String.prototype.trimStart',
+    'URL',
+    'URL.prototype.toJSON',
+    'URLSearchParams',
+    'WeakMap',
+    'WeakSet',
+    'Promise',
+    'Promise.prototype.finally',
+    'es2015',
+    'es2016',
+    'es2017',
+    'es2018',
+    'es2019',
+    'es5',
+    'es6',
+    'es7'
+];
+var url = 'https://nextjs.org/docs/messages/no-unwanted-polyfillio';
+module.exports = (0, _definerule.defineRule)({
+    meta: {
+        docs: {
+            description: 'Prevent duplicate polyfills from Polyfill.io.',
+            category: 'HTML',
+            recommended: true,
+            url: url
+        },
+        type: 'problem',
+        schema: []
+    },
+    create: function create(context) {
+        var scriptImport = null;
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                if (node.source && node.source.value === 'next/script') {
+                    scriptImport = node.specifiers[0].local.name;
+                }
+            },
+            JSXOpeningElement: function JSXOpeningElement(node) {
+                if (node.name && node.name.name !== 'script' && node.name.name !== scriptImport) {
+                    return;
+                }
+                if (node.attributes.length === 0) {
+                    return;
+                }
+                var srcNode = node.attributes.find(function(attr) {
+                    return attr.type === 'JSXAttribute' && attr.name.name === 'src';
+                });
+                if (!srcNode || srcNode.value.type !== 'Literal') {
+                    return;
+                }
+                var src = srcNode.value.value;
+                if (src.startsWith('https://cdn.polyfill.io/v2/') || src.startsWith('https://polyfill.io/v3/') || // https://community.fastly.com/t/new-options-for-polyfill-io-users/2540
+                src.startsWith('https://polyfill-fastly.net/') || src.startsWith('https://polyfill-fastly.io/') || // https://blog.cloudflare.com/polyfill-io-now-available-on-cdnjs-reduce-your-supply-chain-risk
+                src.startsWith('https://cdnjs.cloudflare.com/polyfill/')) {
+                    var featureQueryString = new URL(src).searchParams.get('features');
+                    var featuresRequested = (featureQueryString || '').split(',');
+                    var unwantedFeatures = featuresRequested.filter(function(feature) {
+                        return NEXT_POLYFILLED_FEATURES.includes(feature);
+                    });
+                    if (unwantedFeatures.length > 0) {
+                        context.report({
+                            node: node,
+                            message: "No duplicate polyfills from Polyfill.io are allowed. ".concat(unwantedFeatures.join(', '), " ").concat(unwantedFeatures.length > 1 ? 'are' : 'is', " already shipped with Next.js. See: ").concat(url)
+                        });
+                    }
+                }
+            }
+        };
+    }
+});