vscode-json-languageservice 5.7.2 → 6.0.0-next.2

package/lib/umd/services/schemas/draft-2019-09-flat.js

@@ -1,314 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    // This file is generated - do not edit directly!
-    // Derived from https://json-schema.org/draft/2019-09
-    exports.default = {
-        $id: 'https://json-schema.org/draft/2019-09/schema',
-        $schema: 'https://json-schema.org/draft/2019-09/schema',
-        title: '(Flattened static) Core and Validation specifications meta-schema',
-        type: [
-            'object',
-            'boolean',
-        ],
-        properties: {
-            definitions: {
-                $comment: 'While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.',
-                type: 'object',
-                additionalProperties: {
-                    $ref: '#',
-                },
-                default: {},
-            },
-            dependencies: {
-                $comment: '"dependencies" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to "dependentSchemas" and "dependentRequired"',
-                type: 'object',
-                additionalProperties: {
-                    anyOf: [
-                        {
-                            $ref: '#',
-                        },
-                        {
-                            $ref: '#/$defs/stringArray',
-                        },
-                    ],
-                },
-            },
-            $id: {
-                type: 'string',
-                format: 'uri-reference',
-                $comment: 'Non-empty fragments not allowed.',
-                pattern: '^[^#]*#?$',
-            },
-            $schema: {
-                type: 'string',
-                format: 'uri',
-            },
-            $anchor: {
-                type: 'string',
-                pattern: '^[A-Za-z][-A-Za-z0-9.:_]*$',
-            },
-            $ref: {
-                type: 'string',
-                format: 'uri-reference',
-            },
-            $recursiveAnchor: {
-                type: 'boolean',
-                default: false,
-            },
-            $vocabulary: {
-                type: 'object',
-                propertyNames: {
-                    type: 'string',
-                    format: 'uri',
-                },
-                additionalProperties: {
-                    type: 'boolean',
-                },
-            },
-            $comment: {
-                type: 'string',
-            },
-            $defs: {
-                type: 'object',
-                additionalProperties: {
-                    $ref: '#',
-                },
-                default: {},
-            },
-            additionalItems: {
-                $ref: '#',
-            },
-            unevaluatedItems: {
-                $ref: '#',
-            },
-            items: {
-                anyOf: [
-                    {
-                        $ref: '#',
-                    },
-                    {
-                        $ref: '#/$defs/schemaArray',
-                    },
-                ],
-            },
-            contains: {
-                $ref: '#',
-            },
-            additionalProperties: {
-                $ref: '#',
-            },
-            unevaluatedProperties: {
-                $ref: '#',
-            },
-            properties: {
-                type: 'object',
-                additionalProperties: {
-                    $ref: '#',
-                },
-                default: {},
-            },
-            patternProperties: {
-                type: 'object',
-                additionalProperties: {
-                    $ref: '#',
-                },
-                propertyNames: {
-                    format: 'regex',
-                },
-                default: {},
-            },
-            dependentSchemas: {
-                type: 'object',
-                additionalProperties: {
-                    $ref: '#',
-                },
-            },
-            propertyNames: {
-                $ref: '#',
-            },
-            if: {
-                $ref: '#',
-            },
-            then: {
-                $ref: '#',
-            },
-            else: {
-                $ref: '#',
-            },
-            allOf: {
-                $ref: '#/$defs/schemaArray',
-            },
-            anyOf: {
-                $ref: '#/$defs/schemaArray',
-            },
-            oneOf: {
-                $ref: '#/$defs/schemaArray',
-            },
-            not: {
-                $ref: '#',
-            },
-            multipleOf: {
-                type: 'number',
-                exclusiveMinimum: 0,
-            },
-            maximum: {
-                type: 'number',
-            },
-            exclusiveMaximum: {
-                type: 'number',
-            },
-            minimum: {
-                type: 'number',
-            },
-            exclusiveMinimum: {
-                type: 'number',
-            },
-            maxLength: {
-                $ref: '#/$defs/nonNegativeInteger',
-            },
-            minLength: {
-                $ref: '#/$defs/nonNegativeIntegerDefault0',
-            },
-            pattern: {
-                type: 'string',
-                format: 'regex',
-            },
-            maxItems: {
-                $ref: '#/$defs/nonNegativeInteger',
-            },
-            minItems: {
-                $ref: '#/$defs/nonNegativeIntegerDefault0',
-            },
-            uniqueItems: {
-                type: 'boolean',
-                default: false,
-            },
-            maxContains: {
-                $ref: '#/$defs/nonNegativeInteger',
-            },
-            minContains: {
-                $ref: '#/$defs/nonNegativeInteger',
-                default: 1,
-            },
-            maxProperties: {
-                $ref: '#/$defs/nonNegativeInteger',
-            },
-            minProperties: {
-                $ref: '#/$defs/nonNegativeIntegerDefault0',
-            },
-            required: {
-                $ref: '#/$defs/stringArray',
-            },
-            dependentRequired: {
-                type: 'object',
-                additionalProperties: {
-                    $ref: '#/$defs/stringArray',
-                },
-            },
-            const: true,
-            enum: {
-                type: 'array',
-                items: true,
-            },
-            type: {
-                anyOf: [
-                    {
-                        $ref: '#/$defs/simpleTypes',
-                    },
-                    {
-                        type: 'array',
-                        items: {
-                            $ref: '#/$defs/simpleTypes',
-                        },
-                        minItems: 1,
-                        uniqueItems: true,
-                    },
-                ],
-            },
-            title: {
-                type: 'string',
-            },
-            description: {
-                type: 'string',
-            },
-            default: true,
-            deprecated: {
-                type: 'boolean',
-                default: false,
-            },
-            readOnly: {
-                type: 'boolean',
-                default: false,
-            },
-            writeOnly: {
-                type: 'boolean',
-                default: false,
-            },
-            examples: {
-                type: 'array',
-                items: true,
-            },
-            format: {
-                type: 'string',
-            },
-            contentMediaType: {
-                type: 'string',
-            },
-            contentEncoding: {
-                type: 'string',
-            },
-            contentSchema: {
-                $ref: '#',
-            },
-        },
-        $defs: {
-            schemaArray: {
-                type: 'array',
-                minItems: 1,
-                items: {
-                    $ref: '#',
-                },
-            },
-            nonNegativeInteger: {
-                type: 'integer',
-                minimum: 0,
-            },
-            nonNegativeIntegerDefault0: {
-                $ref: '#/$defs/nonNegativeInteger',
-                default: 0,
-            },
-            simpleTypes: {
-                enum: [
-                    'array',
-                    'boolean',
-                    'integer',
-                    'null',
-                    'number',
-                    'object',
-                    'string',
-                ],
-            },
-            stringArray: {
-                type: 'array',
-                items: {
-                    type: 'string',
-                },
-                uniqueItems: true,
-                default: [],
-            },
-        },
-    };
-});

package/lib/umd/services/schemas/draft-2020-12-flat.d.ts

@@ -1,276 +0,0 @@
-declare const _default: {
-    $id: string;
-    $schema: string;
-    title: string;
-    type: string[];
-    properties: {
-        definitions: {
-            $comment: string;
-            type: string;
-            additionalProperties: {
-                $ref: string;
-            };
-            default: {};
-        };
-        dependencies: {
-            $comment: string;
-            type: string;
-            additionalProperties: {
-                anyOf: {
-                    $ref: string;
-                }[];
-            };
-        };
-        $id: {
-            type: string;
-            format: string;
-            $comment: string;
-            pattern: string;
-        };
-        $schema: {
-            type: string;
-            format: string;
-        };
-        $anchor: {
-            type: string;
-            pattern: string;
-        };
-        $ref: {
-            type: string;
-            format: string;
-        };
-        $dynamicRef: {
-            type: string;
-            format: string;
-        };
-        $vocabulary: {
-            type: string;
-            propertyNames: {
-                type: string;
-                format: string;
-            };
-            additionalProperties: {
-                type: string;
-            };
-        };
-        $comment: {
-            type: string;
-        };
-        $defs: {
-            type: string;
-            additionalProperties: {
-                $ref: string;
-            };
-            default: {};
-        };
-        prefixItems: {
-            $ref: string;
-        };
-        items: {
-            $ref: string;
-        };
-        contains: {
-            $ref: string;
-        };
-        additionalProperties: {
-            $ref: string;
-        };
-        properties: {
-            type: string;
-            additionalProperties: {
-                $ref: string;
-            };
-            default: {};
-        };
-        patternProperties: {
-            type: string;
-            additionalProperties: {
-                $ref: string;
-            };
-            propertyNames: {
-                format: string;
-            };
-            default: {};
-        };
-        dependentSchemas: {
-            type: string;
-            additionalProperties: {
-                $ref: string;
-            };
-        };
-        propertyNames: {
-            $ref: string;
-        };
-        if: {
-            $ref: string;
-        };
-        then: {
-            $ref: string;
-        };
-        else: {
-            $ref: string;
-        };
-        allOf: {
-            $ref: string;
-        };
-        anyOf: {
-            $ref: string;
-        };
-        oneOf: {
-            $ref: string;
-        };
-        not: {
-            $ref: string;
-        };
-        unevaluatedItems: {
-            $ref: string;
-        };
-        unevaluatedProperties: {
-            $ref: string;
-        };
-        multipleOf: {
-            type: string;
-            exclusiveMinimum: number;
-        };
-        maximum: {
-            type: string;
-        };
-        exclusiveMaximum: {
-            type: string;
-        };
-        minimum: {
-            type: string;
-        };
-        exclusiveMinimum: {
-            type: string;
-        };
-        maxLength: {
-            $ref: string;
-        };
-        minLength: {
-            $ref: string;
-        };
-        pattern: {
-            type: string;
-            format: string;
-        };
-        maxItems: {
-            $ref: string;
-        };
-        minItems: {
-            $ref: string;
-        };
-        uniqueItems: {
-            type: string;
-            default: boolean;
-        };
-        maxContains: {
-            $ref: string;
-        };
-        minContains: {
-            $ref: string;
-            default: number;
-        };
-        maxProperties: {
-            $ref: string;
-        };
-        minProperties: {
-            $ref: string;
-        };
-        required: {
-            $ref: string;
-        };
-        dependentRequired: {
-            type: string;
-            additionalProperties: {
-                $ref: string;
-            };
-        };
-        const: boolean;
-        enum: {
-            type: string;
-            items: boolean;
-        };
-        type: {
-            anyOf: ({
-                $ref: string;
-                type?: undefined;
-                items?: undefined;
-                minItems?: undefined;
-                uniqueItems?: undefined;
-            } | {
-                type: string;
-                items: {
-                    $ref: string;
-                };
-                minItems: number;
-                uniqueItems: boolean;
-                $ref?: undefined;
-            })[];
-        };
-        title: {
-            type: string;
-        };
-        description: {
-            type: string;
-        };
-        default: boolean;
-        deprecated: {
-            type: string;
-            default: boolean;
-        };
-        readOnly: {
-            type: string;
-            default: boolean;
-        };
-        writeOnly: {
-            type: string;
-            default: boolean;
-        };
-        examples: {
-            type: string;
-            items: boolean;
-        };
-        format: {
-            type: string;
-        };
-        contentMediaType: {
-            type: string;
-        };
-        contentEncoding: {
-            type: string;
-        };
-        contentSchema: {
-            $ref: string;
-        };
-    };
-    $defs: {
-        schemaArray: {
-            type: string;
-            minItems: number;
-            items: {
-                $ref: string;
-            };
-        };
-        nonNegativeInteger: {
-            type: string;
-            minimum: number;
-        };
-        nonNegativeIntegerDefault0: {
-            $ref: string;
-            default: number;
-        };
-        simpleTypes: {
-            enum: string[];
-        };
-        stringArray: {
-            type: string;
-            items: {
-                type: string;
-            };
-            uniqueItems: boolean;
-            default: never[];
-        };
-    };
-};
-export default _default;