@kubb/agent 4.33.1 → 4.33.2

package/.output/server/node_modules/@redocly/openapi-core/lib/walk.js

@@ -0,0 +1,303 @@
+import { YamlParseError } from './errors/yaml-parse-error.js';
+import { Location, isRef } from './ref-utils.js';
+import { isNamedType, SpecExtension } from './types/index.js';
+import { getOwn } from './utils/get-own.js';
+import { isPlainObject } from './utils/is-plain-object.js';
+import { makeRefId } from './utils/make-ref-id.js';
+import { pushStack, popStack } from './utils/stack.js';
+function collectParents(ctx) {
+    const parents = {};
+    while (ctx.parent) {
+        parents[ctx.parent.type.name] = ctx.parent.activatedOn?.value.node;
+        ctx = ctx.parent;
+    }
+    return parents;
+}
+function collectParentsLocations(ctx) {
+    const locations = {};
+    while (ctx.parent) {
+        if (ctx.parent.activatedOn?.value.location) {
+            locations[ctx.parent.type.name] = ctx.parent.activatedOn?.value.location;
+        }
+        ctx = ctx.parent;
+    }
+    return locations;
+}
+export function walkDocument(opts) {
+    const { document, rootType, normalizedVisitors, resolvedRefMap, ctx } = opts;
+    const seenNodesPerType = {};
+    const ignoredNodes = new Set();
+    walkNode(document.parsed, rootType, new Location(document.source, '#/'), undefined, '');
+    function walkNode(node, type, location, parent, key) {
+        const resolve = (ref, from = currentLocation.source.absoluteRef) => {
+            if (!isRef(ref))
+                return { location, node: ref };
+            const refId = makeRefId(from, ref.$ref);
+            const resolvedRef = resolvedRefMap.get(refId);
+            if (!resolvedRef) {
+                return {
+                    location: undefined,
+                    node: undefined,
+                };
+            }
+            const { resolved, node, document, nodePointer, error } = resolvedRef;
+            const newLocation = resolved
+                ? new Location(document.source, nodePointer)
+                : error instanceof YamlParseError
+                    ? new Location(error.source, '')
+                    : undefined;
+            return { location: newLocation, node, error };
+        };
+        const rawLocation = location;
+        let currentLocation = location;
+        const { node: resolvedNode, location: resolvedLocation, error } = resolve(node);
+        const enteredContexts = new Set();
+        if (isRef(node)) {
+            const refEnterVisitors = normalizedVisitors.ref.enter;
+            for (const { visit: visitor, ruleId, severity, message, context } of refEnterVisitors) {
+                enteredContexts.add(context);
+                const report = reportFn.bind(undefined, ruleId, severity, message);
+                visitor(node, {
+                    report,
+                    resolve,
+                    rawNode: node,
+                    rawLocation,
+                    location,
+                    type,
+                    parent,
+                    key,
+                    parentLocations: {},
+                    specVersion: ctx.specVersion,
+                    config: ctx.config,
+                    getVisitorData: getVisitorDataFn.bind(undefined, ruleId),
+                }, { node: resolvedNode, location: resolvedLocation, error });
+                if (resolvedLocation?.source.absoluteRef && ctx.refTypes) {
+                    ctx.refTypes.set(resolvedLocation?.source.absoluteRef, type);
+                }
+            }
+        }
+        if (resolvedNode !== undefined && resolvedLocation && type.name !== 'scalar') {
+            currentLocation = resolvedLocation;
+            const isNodeSeen = seenNodesPerType[type.name]?.has?.(resolvedNode);
+            let visitedBySome = false;
+            const anyEnterVisitors = normalizedVisitors.any.enter;
+            const currentEnterVisitors = anyEnterVisitors.concat(normalizedVisitors[type.name]?.enter || []);
+            const activatedContexts = [];
+            for (const { context, visit, skip, ruleId, severity, message } of currentEnterVisitors) {
+                if (ignoredNodes.has(`${currentLocation.absolutePointer}${currentLocation.pointer}`))
+                    break;
+                if (context.isSkippedLevel) {
+                    if (context.parent.activatedOn &&
+                        !context.parent.activatedOn.value.nextLevelTypeActivated &&
+                        !context.seen.has(node)) {
+                        // TODO: test for walk through duplicated $ref-ed node
+                        context.seen.add(node);
+                        visitedBySome = true;
+                        activatedContexts.push(context);
+                    }
+                }
+                else {
+                    if ((context.parent && // if nested
+                        context.parent.activatedOn &&
+                        context.activatedOn?.value.withParentNode !== context.parent.activatedOn.value.node &&
+                        // do not enter if visited by parent children (it works thanks because deeper visitors are sorted before)
+                        context.parent.activatedOn.value.nextLevelTypeActivated?.value !== type) ||
+                        (!context.parent && !isNodeSeen) // if top-level visit each node just once
+                    ) {
+                        activatedContexts.push(context);
+                        const activatedOn = {
+                            node: resolvedNode,
+                            location: resolvedLocation,
+                            nextLevelTypeActivated: null,
+                            withParentNode: context.parent?.activatedOn?.value.node,
+                            skipped: (context.parent?.activatedOn?.value.skipped ||
+                                skip?.(resolvedNode, key, {
+                                    location,
+                                    rawLocation,
+                                    resolve,
+                                    rawNode: node,
+                                })) ??
+                                false,
+                        };
+                        context.activatedOn = pushStack(context.activatedOn, activatedOn);
+                        let ctx = context.parent;
+                        while (ctx) {
+                            ctx.activatedOn.value.nextLevelTypeActivated = pushStack(ctx.activatedOn.value.nextLevelTypeActivated, type);
+                            ctx = ctx.parent;
+                        }
+                        if (!activatedOn.skipped) {
+                            visitedBySome = true;
+                            enteredContexts.add(context);
+                            visitWithContext(visit, resolvedNode, node, context, ruleId, severity, message);
+                        }
+                    }
+                }
+            }
+            if (visitedBySome || !isNodeSeen) {
+                seenNodesPerType[type.name] = seenNodesPerType[type.name] || new Set();
+                seenNodesPerType[type.name].add(resolvedNode);
+                if (Array.isArray(resolvedNode)) {
+                    const itemsType = type.items;
+                    if (itemsType !== undefined) {
+                        const isTypeAFunction = typeof itemsType === 'function';
+                        for (let i = 0; i < resolvedNode.length; i++) {
+                            let itemType = isTypeAFunction
+                                ? itemsType(resolvedNode[i], resolvedLocation.child([i]).absolutePointer)
+                                : itemsType;
+                            let itemValue = resolvedNode[i];
+                            if (itemType?.directResolveAs) {
+                                itemType = itemType.directResolveAs;
+                                itemValue = { $ref: itemValue };
+                            }
+                            if (isNamedType(itemType)) {
+                                walkNode(itemValue, itemType, resolvedLocation.child([i]), resolvedNode, i);
+                            }
+                        }
+                    }
+                }
+                else if (isPlainObject(resolvedNode)) {
+                    // visit in order from type-tree first
+                    const props = Object.keys(type.properties);
+                    if (type.additionalProperties) {
+                        props.push(...Object.keys(resolvedNode).filter((k) => !props.includes(k)));
+                    }
+                    else if (type.extensionsPrefix) {
+                        props.push(...Object.keys(resolvedNode).filter((k) => k.startsWith(type.extensionsPrefix)));
+                    }
+                    if (isRef(node)) {
+                        props.push(...Object.keys(node).filter((k) => k !== '$ref' && !props.includes(k))); // properties on the same level as $ref
+                    }
+                    for (const propName of props) {
+                        let value = resolvedNode[propName];
+                        let loc = resolvedLocation;
+                        if (value === undefined) {
+                            value = node[propName];
+                            loc = location; // properties on the same level as $ref should resolve against original location, not target
+                        }
+                        let propType = getOwn(type.properties, propName);
+                        if (propType === undefined)
+                            propType = type.additionalProperties;
+                        if (typeof propType === 'function')
+                            propType = propType(value, propName);
+                        if (propType === undefined &&
+                            type.extensionsPrefix &&
+                            propName.startsWith(type.extensionsPrefix)) {
+                            propType = SpecExtension;
+                        }
+                        if (!isNamedType(propType) && propType?.directResolveAs) {
+                            propType = propType.directResolveAs;
+                            value = { $ref: value };
+                        }
+                        if (propType && propType.name === undefined && propType.resolvable !== false) {
+                            propType = { name: 'scalar', properties: {} };
+                        }
+                        if (isRef(node[propName]) && propType?.name === 'scalar') {
+                            walkNode(node[propName], propType, location.child([propName]), node, propName);
+                            continue;
+                        }
+                        if (!isNamedType(propType) || (propType.name === 'scalar' && !isRef(value))) {
+                            continue;
+                        }
+                        walkNode(value, propType, loc.child([propName]), resolvedNode, propName);
+                    }
+                }
+            }
+            const anyLeaveVisitors = normalizedVisitors.any.leave;
+            const currentLeaveVisitors = (normalizedVisitors[type.name]?.leave || []).concat(anyLeaveVisitors);
+            for (const context of activatedContexts.reverse()) {
+                if (context.isSkippedLevel) {
+                    context.seen.delete(resolvedNode);
+                }
+                else {
+                    context.activatedOn = popStack(context.activatedOn);
+                    if (context.parent) {
+                        let ctx = context.parent;
+                        while (ctx) {
+                            ctx.activatedOn.value.nextLevelTypeActivated = popStack(ctx.activatedOn.value.nextLevelTypeActivated);
+                            ctx = ctx.parent;
+                        }
+                    }
+                }
+            }
+            for (const { context, visit, ruleId, severity, message } of currentLeaveVisitors) {
+                if (!context.isSkippedLevel && enteredContexts.has(context)) {
+                    visitWithContext(visit, resolvedNode, node, context, ruleId, severity, message);
+                }
+            }
+        }
+        currentLocation = location;
+        if (isRef(node)) {
+            const refLeaveVisitors = normalizedVisitors.ref.leave;
+            for (const { visit: visitor, ruleId, severity, context, message } of refLeaveVisitors) {
+                if (enteredContexts.has(context)) {
+                    const report = reportFn.bind(undefined, ruleId, severity, message);
+                    visitor(node, {
+                        report,
+                        resolve,
+                        rawNode: node,
+                        rawLocation,
+                        location,
+                        type,
+                        parent,
+                        key,
+                        parentLocations: {},
+                        specVersion: ctx.specVersion,
+                        config: ctx.config,
+                        getVisitorData: getVisitorDataFn.bind(undefined, ruleId),
+                    }, { node: resolvedNode, location: resolvedLocation, error });
+                }
+            }
+        }
+        // returns true ignores all the next visitors on the specific node
+        function visitWithContext(visit, resolvedNode, node, context, ruleId, severity, customMessage) {
+            const report = reportFn.bind(undefined, ruleId, severity, customMessage);
+            visit(resolvedNode, {
+                report,
+                resolve,
+                rawNode: node,
+                location: currentLocation,
+                rawLocation,
+                type,
+                parent,
+                key,
+                parentLocations: collectParentsLocations(context),
+                specVersion: ctx.specVersion,
+                config: ctx.config,
+                ignoreNextVisitorsOnNode: () => {
+                    ignoredNodes.add(`${currentLocation.absolutePointer}${currentLocation.pointer}`);
+                },
+                getVisitorData: getVisitorDataFn.bind(undefined, ruleId),
+            }, collectParents(context), context);
+        }
+        function reportFn(ruleId, severity, customMessage, opts) {
+            const normalizedLocation = opts.location
+                ? Array.isArray(opts.location)
+                    ? opts.location
+                    : [opts.location]
+                : [{ ...currentLocation, reportOnKey: false }];
+            const location = normalizedLocation.map((l) => ({
+                ...currentLocation,
+                reportOnKey: false,
+                ...l,
+            }));
+            const ruleSeverity = opts.forceSeverity || severity;
+            if (ruleSeverity !== 'off') {
+                ctx.problems.push({
+                    ruleId: opts.ruleId || ruleId,
+                    severity: ruleSeverity,
+                    ...opts,
+                    message: customMessage
+                        ? customMessage.replace('{{message}}', opts.message)
+                        : opts.message,
+                    suggest: opts.suggest || [],
+                    location,
+                });
+            }
+        }
+        function getVisitorDataFn(ruleId) {
+            ctx.visitorsData[ruleId] = ctx.visitorsData[ruleId] || {};
+            return ctx.visitorsData[ruleId];
+        }
+    }
+}
+//# sourceMappingURL=walk.js.map

package/.output/server/node_modules/@redocly/openapi-core/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@redocly/openapi-core",
+  "version": "2.20.4",
+  "description": "",
+  "type": "module",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./lib/index.js",
+      "require": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    },
+    "./lib/bundle-oas": {
+      "import": "./lib/bundle/bundle-oas.js",
+      "require": "./lib/bundle/bundle-oas.js",
+      "types": "./lib/bundle/bundle-oas.d.ts"
+    }
+  },
+  "engines": {
+    "node": ">=22.12.0 || >=20.19.0 <21.0.0",
+    "npm": ">=10"
+  },
+  "engineStrict": true,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Redocly/redocly-cli.git"
+  },
+  "browser": {
+    "fs": false,
+    "path": "path-browserify",
+    "os": false,
+    "node:fs": false,
+    "node:path": "path-browserify",
+    "node:os": false,
+    "node:url": false,
+    "node:module": false,
+    "colorette": false
+  },
+  "homepage": "https://github.com/Redocly/redocly-cli",
+  "keywords": [
+    "linter",
+    "OpenAPI",
+    "Swagger",
+    "OpenAPI linter",
+    "Swagger linter",
+    "AsyncAPI linter",
+    "Arazzo linter",
+    "oas"
+  ],
+  "contributors": [
+    "Roman Hotsiy <roman@redocly.com> (https://redocly.com/)"
+  ],
+  "dependencies": {
+    "@redocly/ajv": "^8.18.0",
+    "@redocly/config": "^0.44.0",
+    "ajv": "npm:@redocly/ajv@8.18.0",
+    "ajv-formats": "^3.0.1",
+    "colorette": "^1.2.0",
+    "js-levenshtein": "^1.1.6",
+    "js-yaml": "^4.1.0",
+    "picomatch": "^4.0.3",
+    "pluralize": "^8.0.0",
+    "yaml-ast-parser": "0.0.43"
+  },
+  "devDependencies": {
+    "@types/js-levenshtein": "^1.1.0",
+    "@types/js-yaml": "^4.0.3",
+    "@types/picomatch": "^4.0.2",
+    "@types/pluralize": "^0.0.29",
+    "json-schema-to-ts": "^3.1.0",
+    "typescript": "5.9.3"
+  }
+}

package/.output/server/node_modules/ajv-formats/dist/formats.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatNames = exports.fastFormats = exports.fullFormats = void 0;
+function fmtDef(validate, compare) {
+    return { validate, compare };
+}
+exports.fullFormats = {
+    // date: http://tools.ietf.org/html/rfc3339#section-5.6
+    date: fmtDef(date, compareDate),
+    // date-time: http://tools.ietf.org/html/rfc3339#section-5.6
+    time: fmtDef(getTime(true), compareTime),
+    "date-time": fmtDef(getDateTime(true), compareDateTime),
+    "iso-time": fmtDef(getTime(), compareIsoTime),
+    "iso-date-time": fmtDef(getDateTime(), compareIsoDateTime),
+    // duration: https://tools.ietf.org/html/rfc3339#appendix-A
+    duration: /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/,
+    uri,
+    "uri-reference": /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,
+    // uri-template: https://tools.ietf.org/html/rfc6570
+    "uri-template": /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,
+    // For the source: https://gist.github.com/dperini/729294
+    // For test cases: https://mathiasbynens.be/demo/url-regex
+    url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
+    email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
+    hostname: /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i,
+    // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html
+    ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,
+    ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i,
+    regex,
+    // uuid: http://tools.ietf.org/html/rfc4122
+    uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
+    // JSON-pointer: https://tools.ietf.org/html/rfc6901
+    // uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A
+    "json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/,
+    "json-pointer-uri-fragment": /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,
+    // relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00
+    "relative-json-pointer": /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,
+    // the following formats are used by the openapi specification: https://spec.openapis.org/oas/v3.0.0#data-types
+    // byte: https://github.com/miguelmota/is-base64
+    byte,
+    // signed 32 bit integer
+    int32: { type: "number", validate: validateInt32 },
+    // signed 64 bit integer
+    int64: { type: "number", validate: validateInt64 },
+    // C-type float
+    float: { type: "number", validate: validateNumber },
+    // C-type double
+    double: { type: "number", validate: validateNumber },
+    // hint to the UI to hide input strings
+    password: true,
+    // unchecked string payload
+    binary: true,
+};
+exports.fastFormats = {
+    ...exports.fullFormats,
+    date: fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d$/, compareDate),
+    time: fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareTime),
+    "date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareDateTime),
+    "iso-time": fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoTime),
+    "iso-date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoDateTime),
+    // uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js
+    uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,
+    "uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,
+    // email (sources from jsen validator):
+    // http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363
+    // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'wilful violation')
+    email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i,
+};
+exports.formatNames = Object.keys(exports.fullFormats);
+function isLeapYear(year) {
+    // https://tools.ietf.org/html/rfc3339#appendix-C
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function date(str) {
+    // full-date from http://tools.ietf.org/html/rfc3339#section-5.6
+    const matches = DATE.exec(str);
+    if (!matches)
+        return false;
+    const year = +matches[1];
+    const month = +matches[2];
+    const day = +matches[3];
+    return (month >= 1 &&
+        month <= 12 &&
+        day >= 1 &&
+        day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]));
+}
+function compareDate(d1, d2) {
+    if (!(d1 && d2))
+        return undefined;
+    if (d1 > d2)
+        return 1;
+    if (d1 < d2)
+        return -1;
+    return 0;
+}
+const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
+function getTime(strictTimeZone) {
+    return function time(str) {
+        const matches = TIME.exec(str);
+        if (!matches)
+            return false;
+        const hr = +matches[1];
+        const min = +matches[2];
+        const sec = +matches[3];
+        const tz = matches[4];
+        const tzSign = matches[5] === "-" ? -1 : 1;
+        const tzH = +(matches[6] || 0);
+        const tzM = +(matches[7] || 0);
+        if (tzH > 23 || tzM > 59 || (strictTimeZone && !tz))
+            return false;
+        if (hr <= 23 && min <= 59 && sec < 60)
+            return true;
+        // leap second
+        const utcMin = min - tzM * tzSign;
+        const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0);
+        return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61;
+    };
+}
+function compareTime(s1, s2) {
+    if (!(s1 && s2))
+        return undefined;
+    const t1 = new Date("2020-01-01T" + s1).valueOf();
+    const t2 = new Date("2020-01-01T" + s2).valueOf();
+    if (!(t1 && t2))
+        return undefined;
+    return t1 - t2;
+}
+function compareIsoTime(t1, t2) {
+    if (!(t1 && t2))
+        return undefined;
+    const a1 = TIME.exec(t1);
+    const a2 = TIME.exec(t2);
+    if (!(a1 && a2))
+        return undefined;
+    t1 = a1[1] + a1[2] + a1[3];
+    t2 = a2[1] + a2[2] + a2[3];
+    if (t1 > t2)
+        return 1;
+    if (t1 < t2)
+        return -1;
+    return 0;
+}
+const DATE_TIME_SEPARATOR = /t|\s/i;
+function getDateTime(strictTimeZone) {
+    const time = getTime(strictTimeZone);
+    return function date_time(str) {
+        // http://tools.ietf.org/html/rfc3339#section-5.6
+        const dateTime = str.split(DATE_TIME_SEPARATOR);
+        return dateTime.length === 2 && date(dateTime[0]) && time(dateTime[1]);
+    };
+}
+function compareDateTime(dt1, dt2) {
+    if (!(dt1 && dt2))
+        return undefined;
+    const d1 = new Date(dt1).valueOf();
+    const d2 = new Date(dt2).valueOf();
+    if (!(d1 && d2))
+        return undefined;
+    return d1 - d2;
+}
+function compareIsoDateTime(dt1, dt2) {
+    if (!(dt1 && dt2))
+        return undefined;
+    const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR);
+    const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR);
+    const res = compareDate(d1, d2);
+    if (res === undefined)
+        return undefined;
+    return res || compareTime(t1, t2);
+}
+const NOT_URI_FRAGMENT = /\/|:/;
+const URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
+function uri(str) {
+    // http://jmrware.com/articles/2009/uri_regexp/URI_regex.html + optional protocol + required "."
+    return NOT_URI_FRAGMENT.test(str) && URI.test(str);
+}
+const BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
+function byte(str) {
+    BYTE.lastIndex = 0;
+    return BYTE.test(str);
+}
+const MIN_INT32 = -(2 ** 31);
+const MAX_INT32 = 2 ** 31 - 1;
+function validateInt32(value) {
+    return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32;
+}
+function validateInt64(value) {
+    // JSON and javascript max Int is 2**53, so any int that passes isInteger is valid for Int64
+    return Number.isInteger(value);
+}
+function validateNumber() {
+    return true;
+}
+const Z_ANCHOR = /[^\\]\\Z/;
+function regex(str) {
+    if (Z_ANCHOR.test(str))
+        return false;
+    try {
+        new RegExp(str);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+//# sourceMappingURL=formats.js.map

package/.output/server/node_modules/ajv-formats/dist/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const formats_1 = require("./formats");
+const limit_1 = require("./limit");
+const codegen_1 = require("ajv/dist/compile/codegen");
+const fullName = new codegen_1.Name("fullFormats");
+const fastName = new codegen_1.Name("fastFormats");
+const formatsPlugin = (ajv, opts = { keywords: true }) => {
+    if (Array.isArray(opts)) {
+        addFormats(ajv, opts, formats_1.fullFormats, fullName);
+        return ajv;
+    }
+    const [formats, exportName] = opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName];
+    const list = opts.formats || formats_1.formatNames;
+    addFormats(ajv, list, formats, exportName);
+    if (opts.keywords)
+        (0, limit_1.default)(ajv);
+    return ajv;
+};
+formatsPlugin.get = (name, mode = "full") => {
+    const formats = mode === "fast" ? formats_1.fastFormats : formats_1.fullFormats;
+    const f = formats[name];
+    if (!f)
+        throw new Error(`Unknown format "${name}"`);
+    return f;
+};
+function addFormats(ajv, list, fs, exportName) {
+    var _a;
+    var _b;
+    (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : (_b.formats = (0, codegen_1._) `require("ajv-formats/dist/formats").${exportName}`);
+    for (const f of list)
+        ajv.addFormat(f, fs[f]);
+}
+module.exports = exports = formatsPlugin;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = formatsPlugin;
+//# sourceMappingURL=index.js.map