immosquare-cleaner 0.1.9 → 0.1.10

data/node_modules/eslint-plugin-jsonc/dist/rules/sort-keys.js

@@ -1,413 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const natural_compare_1 = __importDefault(require("natural-compare"));
-const utils_1 = require("../utils");
-const eslint_utils_1 = require("@eslint-community/eslint-utils");
-const jsonc_eslint_parser_1 = require("jsonc-eslint-parser");
-function getPropertyName(node) {
-    const prop = node.key;
-    if (prop.type === "JSONIdentifier") {
-        return prop.name;
-    }
-    return String((0, jsonc_eslint_parser_1.getStaticJSONValue)(prop));
-}
-class JSONPropertyData {
-    get reportLoc() {
-        return this.node.key.loc;
-    }
-    constructor(object, node, index) {
-        this.cachedName = null;
-        this.object = object;
-        this.node = node;
-        this.index = index;
-    }
-    get name() {
-        var _a;
-        return ((_a = this.cachedName) !== null && _a !== void 0 ? _a : (this.cachedName = getPropertyName(this.node)));
-    }
-    getPrev() {
-        const prevIndex = this.index - 1;
-        return prevIndex >= 0 ? this.object.properties[prevIndex] : null;
-    }
-}
-class JSONObjectData {
-    constructor(node) {
-        this.cachedProperties = null;
-        this.node = node;
-    }
-    get properties() {
-        var _a;
-        return ((_a = this.cachedProperties) !== null && _a !== void 0 ? _a : (this.cachedProperties = this.node.properties.map((e, index) => new JSONPropertyData(this, e, index))));
-    }
-    getPath() {
-        let path = "";
-        let curr = this.node;
-        let p = curr.parent;
-        while (p) {
-            if (p.type === "JSONProperty") {
-                const name = getPropertyName(p);
-                if (/^[$_a-z][\w$]*$/iu.test(name)) {
-                    path = `.${name}${path}`;
-                }
-                else {
-                    path = `[${JSON.stringify(name)}]${path}`;
-                }
-                curr = p.parent;
-            }
-            else if (p.type === "JSONArrayExpression") {
-                const index = p.elements.indexOf(curr);
-                path = `[${index}]${path}`;
-                curr = p;
-            }
-            else if (p.type === "JSONExpressionStatement") {
-                break;
-            }
-            else {
-                curr = p;
-            }
-            p = curr.parent;
-        }
-        if (path.startsWith(".")) {
-            path = path.slice(1);
-        }
-        return path;
-    }
-}
-function isCompatibleWithESLintOptions(options) {
-    if (options.length === 0) {
-        return true;
-    }
-    if (typeof options[0] === "string" || options[0] == null) {
-        return true;
-    }
-    return false;
-}
-function buildValidatorFromType(order, insensitive, natural) {
-    let compare = natural
-        ? ([a, b]) => (0, natural_compare_1.default)(a, b) <= 0
-        : ([a, b]) => a <= b;
-    if (insensitive) {
-        const baseCompare = compare;
-        compare = ([a, b]) => baseCompare([a.toLowerCase(), b.toLowerCase()]);
-    }
-    if (order === "desc") {
-        const baseCompare = compare;
-        compare = (args) => baseCompare(args.reverse());
-    }
-    return (a, b) => compare([a.name, b.name]);
-}
-function parseOptions(options) {
-    var _a, _b, _c;
-    if (isCompatibleWithESLintOptions(options)) {
-        const type = (_a = options[0]) !== null && _a !== void 0 ? _a : "asc";
-        const obj = (_b = options[1]) !== null && _b !== void 0 ? _b : {};
-        const insensitive = obj.caseSensitive === false;
-        const natural = Boolean(obj.natural);
-        const minKeys = (_c = obj.minKeys) !== null && _c !== void 0 ? _c : 2;
-        const allowLineSeparatedGroups = obj.allowLineSeparatedGroups || false;
-        return [
-            {
-                isTargetObject: (node) => node.properties.length >= minKeys,
-                ignore: () => false,
-                isValidOrder: buildValidatorFromType(type, insensitive, natural),
-                orderText: `${natural ? "natural " : ""}${insensitive ? "insensitive " : ""}${type}ending`,
-                allowLineSeparatedGroups,
-            },
-        ];
-    }
-    return options.map((opt) => {
-        var _a, _b, _c, _d, _e;
-        const order = opt.order;
-        const pathPattern = new RegExp(opt.pathPattern);
-        const hasProperties = (_a = opt.hasProperties) !== null && _a !== void 0 ? _a : [];
-        const minKeys = (_b = opt.minKeys) !== null && _b !== void 0 ? _b : 2;
-        const allowLineSeparatedGroups = opt.allowLineSeparatedGroups || false;
-        if (!Array.isArray(order)) {
-            const type = (_c = order.type) !== null && _c !== void 0 ? _c : "asc";
-            const insensitive = order.caseSensitive === false;
-            const natural = Boolean(order.natural);
-            return {
-                isTargetObject,
-                ignore: () => false,
-                isValidOrder: buildValidatorFromType(type, insensitive, natural),
-                orderText: `${natural ? "natural " : ""}${insensitive ? "insensitive " : ""}${type}ending`,
-                allowLineSeparatedGroups,
-            };
-        }
-        const parsedOrder = [];
-        for (const o of order) {
-            if (typeof o === "string") {
-                parsedOrder.push({
-                    test: (data) => data.name === o,
-                    isValidNestOrder: () => true,
-                });
-            }
-            else {
-                const keyPattern = o.keyPattern ? new RegExp(o.keyPattern) : null;
-                const nestOrder = (_d = o.order) !== null && _d !== void 0 ? _d : {};
-                const type = (_e = nestOrder.type) !== null && _e !== void 0 ? _e : "asc";
-                const insensitive = nestOrder.caseSensitive === false;
-                const natural = Boolean(nestOrder.natural);
-                parsedOrder.push({
-                    test: (data) => (keyPattern ? keyPattern.test(data.name) : true),
-                    isValidNestOrder: buildValidatorFromType(type, insensitive, natural),
-                });
-            }
-        }
-        return {
-            isTargetObject,
-            ignore: (data) => parsedOrder.every((p) => !p.test(data)),
-            isValidOrder(a, b) {
-                for (const p of parsedOrder) {
-                    const matchA = p.test(a);
-                    const matchB = p.test(b);
-                    if (!matchA || !matchB) {
-                        if (matchA) {
-                            return true;
-                        }
-                        if (matchB) {
-                            return false;
-                        }
-                        continue;
-                    }
-                    return p.isValidNestOrder(a, b);
-                }
-                return false;
-            },
-            orderText: "specified",
-            allowLineSeparatedGroups,
-        };
-        function isTargetObject(data) {
-            if (data.node.properties.length < minKeys) {
-                return false;
-            }
-            if (hasProperties.length > 0) {
-                const names = new Set(data.properties.map((p) => p.name));
-                if (!hasProperties.every((name) => names.has(name))) {
-                    return false;
-                }
-            }
-            return pathPattern.test(data.getPath());
-        }
-    });
-}
-const ALLOW_ORDER_TYPES = ["asc", "desc"];
-const ORDER_OBJECT_SCHEMA = {
-    type: "object",
-    properties: {
-        type: {
-            enum: ALLOW_ORDER_TYPES,
-        },
-        caseSensitive: {
-            type: "boolean",
-        },
-        natural: {
-            type: "boolean",
-        },
-    },
-    additionalProperties: false,
-};
-exports.default = (0, utils_1.createRule)("sort-keys", {
-    meta: {
-        docs: {
-            description: "require object keys to be sorted",
-            recommended: null,
-            extensionRule: false,
-            layout: false,
-        },
-        fixable: "code",
-        schema: {
-            oneOf: [
-                {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        properties: {
-                            pathPattern: { type: "string" },
-                            hasProperties: {
-                                type: "array",
-                                items: { type: "string" },
-                            },
-                            order: {
-                                oneOf: [
-                                    {
-                                        type: "array",
-                                        items: {
-                                            anyOf: [
-                                                { type: "string" },
-                                                {
-                                                    type: "object",
-                                                    properties: {
-                                                        keyPattern: {
-                                                            type: "string",
-                                                        },
-                                                        order: ORDER_OBJECT_SCHEMA,
-                                                    },
-                                                    additionalProperties: false,
-                                                },
-                                            ],
-                                        },
-                                        uniqueItems: true,
-                                    },
-                                    ORDER_OBJECT_SCHEMA,
-                                ],
-                            },
-                            minKeys: {
-                                type: "integer",
-                                minimum: 2,
-                            },
-                            allowLineSeparatedGroups: {
-                                type: "boolean",
-                            },
-                        },
-                        required: ["pathPattern", "order"],
-                        additionalProperties: false,
-                    },
-                    minItems: 1,
-                },
-                {
-                    type: "array",
-                    items: [
-                        {
-                            enum: ALLOW_ORDER_TYPES,
-                        },
-                        {
-                            type: "object",
-                            properties: {
-                                caseSensitive: {
-                                    type: "boolean",
-                                },
-                                natural: {
-                                    type: "boolean",
-                                },
-                                minKeys: {
-                                    type: "integer",
-                                    minimum: 2,
-                                },
-                                allowLineSeparatedGroups: {
-                                    type: "boolean",
-                                },
-                            },
-                            additionalProperties: false,
-                        },
-                    ],
-                    additionalItems: false,
-                },
-            ],
-        },
-        messages: {
-            sortKeys: "Expected object keys to be in {{orderText}} order. '{{thisName}}' should be before '{{prevName}}'.",
-        },
-        type: "suggestion",
-    },
-    create(context) {
-        if (!context.parserServices.isJSON) {
-            return {};
-        }
-        const parsedOptions = parseOptions(context.options);
-        const sourceCode = context.getSourceCode();
-        function verifyProperty(data, option) {
-            if (option.ignore(data)) {
-                return;
-            }
-            const prevList = [];
-            let currTarget = data;
-            let prevTarget;
-            while ((prevTarget = currTarget.getPrev())) {
-                if (option.allowLineSeparatedGroups) {
-                    if (hasBlankLine(prevTarget, currTarget)) {
-                        break;
-                    }
-                }
-                if (!option.ignore(prevTarget)) {
-                    prevList.push(prevTarget);
-                }
-                currTarget = prevTarget;
-            }
-            if (prevList.length === 0) {
-                return;
-            }
-            const prev = prevList[0];
-            if (!option.isValidOrder(prev, data)) {
-                context.report({
-                    loc: data.reportLoc,
-                    messageId: "sortKeys",
-                    data: {
-                        thisName: data.name,
-                        prevName: prev.name,
-                        orderText: option.orderText,
-                    },
-                    *fix(fixer) {
-                        let moveTarget = prevList[0];
-                        for (const prev of prevList) {
-                            if (option.isValidOrder(prev, data)) {
-                                break;
-                            }
-                            else {
-                                moveTarget = prev;
-                            }
-                        }
-                        const beforeToken = sourceCode.getTokenBefore(data.node);
-                        const afterToken = sourceCode.getTokenAfter(data.node);
-                        const hasAfterComma = (0, eslint_utils_1.isCommaToken)(afterToken);
-                        const codeStart = beforeToken.range[1];
-                        const codeEnd = hasAfterComma
-                            ? afterToken.range[1]
-                            : data.node.range[1];
-                        const removeStart = hasAfterComma
-                            ? codeStart
-                            : beforeToken.range[0];
-                        const insertCode = sourceCode.text.slice(codeStart, codeEnd) +
-                            (hasAfterComma ? "" : ",");
-                        const insertTarget = sourceCode.getTokenBefore(moveTarget.node);
-                        let insertRange = insertTarget.range;
-                        const insertNext = sourceCode.getTokenAfter(insertTarget, {
-                            includeComments: true,
-                        });
-                        if (insertNext.loc.start.line - insertTarget.loc.end.line > 1) {
-                            const offset = sourceCode.getIndexFromLoc({
-                                line: insertNext.loc.start.line - 1,
-                                column: 0,
-                            });
-                            insertRange = [offset, offset];
-                        }
-                        yield fixer.insertTextAfterRange(insertRange, insertCode);
-                        yield fixer.removeRange([removeStart, codeEnd]);
-                    },
-                });
-            }
-        }
-        function hasBlankLine(prev, next) {
-            const tokenOrNodes = [
-                ...sourceCode.getTokensBetween(prev.node, next.node, {
-                    includeComments: true,
-                }),
-                next.node,
-            ];
-            let prevLoc = prev.node.loc;
-            for (const t of tokenOrNodes) {
-                const loc = t.loc;
-                if (loc.start.line - prevLoc.end.line > 1) {
-                    return true;
-                }
-                prevLoc = loc;
-            }
-            return false;
-        }
-        return {
-            JSONObjectExpression(node) {
-                const data = new JSONObjectData(node);
-                const option = parsedOptions.find((o) => o.isTargetObject(data));
-                if (!option) {
-                    return;
-                }
-                for (const prop of data.properties) {
-                    verifyProperty(prop, option);
-                }
-            },
-        };
-    },
-});

data/node_modules/eslint-plugin-jsonc/dist/rules/space-unary-ops.js

@@ -1,23 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("../utils");
-const coreRule = (0, utils_1.getCoreRule)("space-unary-ops");
-exports.default = (0, utils_1.createRule)("space-unary-ops", {
-    meta: {
-        docs: {
-            description: "disallow spaces after unary operators",
-            recommended: ["json", "jsonc", "json5"],
-            extensionRule: true,
-            layout: true,
-        },
-        fixable: (_a = coreRule.meta) === null || _a === void 0 ? void 0 : _a.fixable,
-        hasSuggestions: coreRule.meta.hasSuggestions,
-        schema: coreRule.meta.schema,
-        messages: coreRule.meta.messages,
-        type: coreRule.meta.type,
-    },
-    create(context) {
-        return (0, utils_1.defineWrapperListener)(coreRule, context, [{ nonwords: false }]);
-    },
-});

data/node_modules/eslint-plugin-jsonc/dist/rules/valid-json-number.js

@@ -1,138 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const jsonc_eslint_parser_1 = require("jsonc-eslint-parser");
-const utils_1 = require("../utils");
-const nonDecimalNumericLiteralPattern = /^0[\dBOXbox]/u;
-function isValidNumber(text) {
-    try {
-        JSON.parse(text);
-    }
-    catch (_a) {
-        return false;
-    }
-    return true;
-}
-exports.default = (0, utils_1.createRule)("valid-json-number", {
-    meta: {
-        docs: {
-            description: "disallow invalid number for JSON",
-            recommended: ["json", "jsonc"],
-            extensionRule: false,
-            layout: false,
-        },
-        fixable: "code",
-        schema: [],
-        messages: {
-            invalid: "Invalid number for JSON.",
-            invalidSpace: "Spaces after minus sign are not allowed in JSON.",
-            invalidPlus: "Plus signs are not allowed in JSON.",
-            invalidIdentifier: "`{{name}}` are not allowed in JSON.",
-            invalidLeadingDecimalPoint: "Leading decimal point is not allowed in JSON.",
-            invalidTrailingDecimalPoint: "Trailing decimal point is not allowed in JSON.",
-            invalidHex: "Hexadecimal literals are not allowed in JSON.",
-            invalidOctal: "Octal literals are not allowed in JSON.",
-            invalidBinary: "Binary literals are not allowed in JSON.",
-        },
-        type: "problem",
-    },
-    create(context) {
-        if (!context.parserServices.isJSON) {
-            return {};
-        }
-        const sourceCode = context.getSourceCode();
-        return {
-            JSONUnaryExpression(node) {
-                if (node.argument.type === "JSONIdentifier") {
-                    return;
-                }
-                const operator = sourceCode.getFirstToken(node, (token) => token.type === "Punctuator" && token.value === node.operator);
-                if (node.operator === "+") {
-                    context.report({
-                        loc: (operator === null || operator === void 0 ? void 0 : operator.loc) || node.loc,
-                        messageId: "invalidPlus",
-                        fix(fixer) {
-                            return operator ? fixer.removeRange(operator.range) : null;
-                        },
-                    });
-                }
-                else if (operator && operator.range[1] < node.argument.range[0]) {
-                    context.report({
-                        loc: {
-                            start: operator.loc.end,
-                            end: node.argument.loc.start,
-                        },
-                        messageId: "invalidSpace",
-                        fix(fixer) {
-                            return fixer.removeRange([
-                                operator.range[1],
-                                node.argument.range[0],
-                            ]);
-                        },
-                    });
-                }
-            },
-            JSONLiteral(node) {
-                if (typeof node.value !== "number") {
-                    return;
-                }
-                const text = sourceCode.text.slice(...node.range);
-                if (text.startsWith(".")) {
-                    context.report({
-                        loc: node.loc,
-                        messageId: "invalidLeadingDecimalPoint",
-                        fix(fixer) {
-                            return fixer.insertTextBeforeRange(node.range, "0");
-                        },
-                    });
-                    return;
-                }
-                if (text.endsWith(".")) {
-                    context.report({
-                        loc: node.loc,
-                        messageId: "invalidTrailingDecimalPoint",
-                        fix(fixer) {
-                            return fixer.removeRange([node.range[1] - 1, node.range[1]]);
-                        },
-                    });
-                    return;
-                }
-                if (nonDecimalNumericLiteralPattern.test(text)) {
-                    context.report({
-                        loc: node.loc,
-                        messageId: text[1].toLowerCase() === "x"
-                            ? "invalidHex"
-                            : text[1].toLowerCase() === "b"
-                                ? "invalidBinary"
-                                : "invalidOctal",
-                        fix: buildFix(node),
-                    });
-                    return;
-                }
-                if (!isValidNumber(text)) {
-                    context.report({
-                        loc: node.loc,
-                        messageId: "invalid",
-                        fix: buildFix(node),
-                    });
-                }
-            },
-            JSONIdentifier(node) {
-                if (!(0, jsonc_eslint_parser_1.isNumberIdentifier)(node)) {
-                    return;
-                }
-                context.report({
-                    loc: node.loc,
-                    messageId: "invalidIdentifier",
-                    data: {
-                        name: node.name,
-                    },
-                });
-            },
-        };
-        function buildFix(node) {
-            return (fixer) => {
-                return fixer.replaceTextRange(node.range, `${node.value}`);
-            };
-        }
-    },
-});

data/node_modules/eslint-plugin-jsonc/dist/rules/vue-custom-block/no-parsing-error.js

@@ -1,86 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("../../utils");
-const jsoncESLintParser = __importStar(require("jsonc-eslint-parser"));
-exports.default = (0, utils_1.createRule)("vue-custom-block/no-parsing-error", {
-    meta: {
-        docs: {
-            description: "disallow parsing errors in Vue custom blocks",
-            recommended: ["json", "json5", "jsonc"],
-            extensionRule: false,
-            layout: false,
-        },
-        schema: [],
-        messages: {},
-        type: "problem",
-    },
-    create(context, { customBlock }) {
-        if (!customBlock) {
-            return {};
-        }
-        const parseError = context.parserServices.parseError;
-        if (parseError) {
-            return errorReportVisitor(context, parseError);
-        }
-        const parseCustomBlockElement = context.parserServices.parseCustomBlockElement;
-        const customBlockElement = context.parserServices.customBlock;
-        if (customBlockElement && parseCustomBlockElement) {
-            let lang = getLang(customBlockElement);
-            if (!lang) {
-                lang = "json";
-            }
-            const { error } = parseCustomBlockElement(jsoncESLintParser, {
-                jsonSyntax: lang,
-            });
-            if (error) {
-                return errorReportVisitor(context, error);
-            }
-        }
-        return {};
-    },
-});
-function errorReportVisitor(context, error) {
-    let loc = undefined;
-    if ("column" in error && "lineNumber" in error) {
-        loc = {
-            line: error.lineNumber,
-            column: error.column,
-        };
-    }
-    return {
-        Program(node) {
-            context.report({
-                node,
-                loc,
-                message: error.message,
-            });
-        },
-    };
-}
-function getLang(customBlock) {
-    var _a, _b;
-    return (((_b = (_a = customBlock.startTag.attributes.find((attr) => !attr.directive && attr.key.name === "lang")) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.value) || null);
-}

data/node_modules/eslint-plugin-jsonc/dist/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });