@redocly/openapi-docs 3.11.0-next.10 → 3.11.0-next.2

package/lib-esm/services/types.d.ts

@@ -0,0 +1,123 @@
+import type { REDOCLY_TEAMS_RBAC } from '@redocly/config';
+import type { ReactElement } from 'react';
+import type { Node } from '@markdoc/markdoc';
+import type { OpenAPIDefinition, OpenAPIInfo, OpenAPIOperation, OpenAPIParameter, OpenAPISchema, OpenAPIServer, OpenAPITag, Referenced } from '../types';
+import type { OperationModel, Sample } from '../models';
+export type Normalized<T> = {
+    [P in keyof T]-?: T[P];
+};
+export type ExternalLink = ExternalLinkLink | ExternalLinkSeparator;
+export type ExternalLinkLink = {
+    label: string;
+    link: string;
+    target?: string;
+    separatorLine?: boolean;
+};
+export type ExternalLinkSeparator = {
+    separator?: string;
+    separatorLine?: boolean;
+};
+export type MenuItemGroupType = 'group' | 'tag' | 'section' | 'schema';
+export type MenuItemType = MenuItemGroupType | 'operation';
+/** Generic interface for MenuItems */
+export interface IMenuItem {
+    id: string;
+    href: string;
+    name: string;
+    description?: string | GenericObject;
+    depth: number;
+    items: IMenuItem[];
+    parent?: IMenuItem;
+    deprecated?: boolean;
+    type: MenuItemType;
+    isSchema?: boolean;
+    httpVerb?: string;
+    isWebhook?: boolean;
+    path?: string;
+    definition?: OpenAPIDefinition;
+    [REDOCLY_TEAMS_RBAC]?: Record<string, string>;
+}
+export type TagInfo = OpenAPITag & {
+    operations: ExtendedOpenAPIOperation[];
+    used?: boolean;
+    schemaRendersInTag?: boolean;
+    isSchema?: boolean;
+};
+export type ExtendedOpenAPIOperation = {
+    pointer: string;
+    pathName: string;
+    httpVerb: string;
+    pathParameters: Array<Referenced<OpenAPIParameter>>;
+    pathServers: Array<OpenAPIServer> | undefined;
+    isWebhook: boolean;
+    defaultSampleName?: string | false;
+} & OpenAPIOperation;
+export type TagsInfoMap = Record<string, TagInfo>;
+export interface TagGroup {
+    name: string;
+    tags: string[];
+}
+export type MergedOpenAPISchema = OpenAPISchema & {
+    'x-refsStack'?: string[];
+    'x-parentRefs'?: string[];
+    'x-circular-ref'?: boolean;
+    'x-complex'?: boolean;
+    absolutePointer?: string;
+};
+export interface MarkdownHeading {
+    id: string;
+    name: string;
+    level: number;
+    items?: MarkdownHeading[];
+    description?: string | GenericObject;
+    ast?: Node[];
+}
+export type Unstable_ExternalCodeSample = Sample & {
+    get: (source: ExternalSource) => string;
+};
+export interface ExternalSource {
+    sample: Unstable_ExternalCodeSample;
+    operation: OperationModel;
+    exampleName?: string;
+    pathParams?: any;
+    properties?: any;
+}
+export interface HookRawHtml {
+    html: string;
+}
+type HookResult = ReactElement | HookRawHtml | null;
+export type HookConfig<T> = (props: T) => HookResult;
+export interface HooksConfig {
+    AfterApiTitle?: HookConfig<{
+        info: OpenAPIInfo;
+    }>;
+    BeforeOperation?: HookConfig<{
+        operation: OperationModel;
+    }>;
+    BeforeOperationSummary?: HookConfig<{
+        operation: OperationModel;
+    }>;
+    AfterOperationSummary?: HookConfig<{
+        operation: OperationModel;
+    }>;
+    AfterOperation?: HookConfig<{
+        operation: OperationModel;
+    }>;
+    onInit?: (args: {
+        store: GenericObject;
+    }) => void;
+    replaceSecurityLink?: (args: {
+        securityRequirementId: string;
+    }) => string;
+    sanitize?: (raw: string) => string;
+    MiddlePanelFooter?: HookConfig<undefined>;
+    MiddlePanelHeader?: HookConfig<undefined>;
+}
+export type ExtendedMenuItem = Omit<IMenuItem, 'type'> & {
+    type: MenuItemType | 'spec';
+    linkable?: boolean;
+    href?: string;
+    httpVerb?: string;
+    path?: string;
+};
+export {};

package/lib-esm/services/types.js

@@ -0,0 +1,2 @@
+export{};
+//# sourceMappingURL=types.js.map

package/lib-esm/services/utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Compare mime-types ignoring charset or other params (application/json;charset=UTF-8)
+ * @param a
+ * @param b
+ */
+export declare function isSameMime(a?: string, b?: string): boolean;
+/**
+ * Removes the mime-types params e.g. charset (application/json;charset=UTF-8))
+ * Removes any prefixes, e.g. application/hal+json => application/json
+ * Spec is type/subtype;param1=value or type/semantic+format;param1=value
+ * @param mimeType mime type string or undefined
+ */
+export declare function normalizeMimeType(mimeType?: string): string | undefined;
+export declare function unescapeServerVariables(str: string): string;
+export declare function arrayMergeStrategy<T>(target: T[], source: T[]): T[];
+export declare function isEmptyObject(obj: GenericObject): boolean;
+export declare const cryptoLib: Crypto | undefined;
+export declare function deepClone(inObject: any): any;

package/lib-esm/services/utils.js

@@ -0,0 +1,2 @@
+import merge from"deepmerge";import{isObject}from"@redocly/theme";import{isMergeableObject}from"../utils";export function isSameMime(e,r){return!(!e||!r)&&normalizeMimeType(e)===normalizeMimeType(r)}export function normalizeMimeType(e){if(!e)return;const r=e.split(";")[0].toLowerCase(),[t,n]=r.split("/");if(void 0===n)return t;return`${t}/${n.split("+").pop()}`}export function unescapeServerVariables(e){const r=new RegExp("%7B","g"),t=new RegExp("%7D","g");return e.replace(r,"{").replace(t,"}").replace("///","//").replace("./",".")}export function arrayMergeStrategy(e,r){if(!e.length||!hasObjectOrArray(e))return r;const t=e.filter((e=>Object.keys(e).length>0));return r.forEach((function(r,n){isMergeableObject(r)?t[n]=merge(e[n],r,{arrayMerge:arrayMergeStrategy}):Array.isArray(r)?t.push(r):t[n]=r})),t}const hasObjectOrArray=e=>e.some((e=>isObject(e)&&Object.keys(e).length>0));export function isEmptyObject(e){return!!e&&0===Object.keys(e).length}export const cryptoLib="undefined"!=typeof window&&(window.crypto||window.msCrypto)||void 0;export function deepClone(e){if("object"!=typeof e||null===e)return e;const r=Array.isArray(e)?[]:{};for(const t in e){const n=e[t];r[t]=deepClone(n)}return r}
+//# sourceMappingURL=utils.js.map

package/lib-esm/standalone.d.ts

@@ -0,0 +1,24 @@
+import 'core-js/es/array/find-index';
+import 'core-js/es/array/find';
+import 'core-js/es/array/includes';
+import 'core-js/es/map';
+import 'core-js/es/number/is-integer';
+import 'core-js/es/object/assign';
+import 'core-js/es/object/entries';
+import 'core-js/es/object/is';
+import 'core-js/es/object/values';
+import 'core-js/es/promise';
+import 'core-js/es/string/ends-with';
+import 'core-js/es/string/starts-with';
+import 'core-js/es/symbol';
+import 'unfetch/polyfill/index';
+import 'url-polyfill';
+import type { RedocConfig } from '@redocly/config';
+import type { OpenAPIDefinition } from './types';
+import type { StoreProviderProps } from './components';
+export { setSecurityDetails, setParameterValue, setSecurityDetailsVariants } from './utils';
+export declare function hydrate(store: StoreProviderProps, element?: Element | null): void;
+export declare function init(definitionOrDefinitionUrl: string | OpenAPIDefinition, options?: RedocConfig, element?: Element | null): void;
+export declare function setPublicPath(path: string): void;
+export declare const version: string;
+export declare const revision: string;

package/lib-esm/standalone.js

@@ -0,0 +1,2 @@
+import{jsx as _jsx}from"react/jsx-runtime";import"core-js/es/array/find-index";import"core-js/es/array/find";import"core-js/es/array/includes";import"core-js/es/map";import"core-js/es/number/is-integer";import"core-js/es/object/assign";import"core-js/es/object/entries";import"core-js/es/object/is";import"core-js/es/object/values";import"core-js/es/promise";import"core-js/es/string/ends-with";import"core-js/es/string/starts-with";import"core-js/es/symbol";import"unfetch/polyfill/index";import"url-polyfill";import{dirname}from"path";import{createElement}from"react";import{createRoot,hydrateRoot}from"react-dom/client";import{IS_BROWSER}from"@redocly/theme";import{querySelector,getJsUrl}from"./utils";import{RedoclyOpenAPIDocs,RedoclyOpenAPIDocsStandalone}from"./components";export{setSecurityDetails,setParameterValue,setSecurityDetailsVariants}from"./utils";const url=getJsUrl(),__dirname=url?dirname(url)+"/":"";function attributesMap(e){const t={},r=e.attributes;for(let e=0;e<r.length;e++){const o=r[e];t[o.name]=o.value}return t}function parseOptionsFromElement(e){const t=attributesMap(e),r={};for(const e in t){r[e.replace(/-(.)/g,((e,t)=>t.toUpperCase()))]=t[e]}return r}export function hydrate(e,t=document.querySelector("redoc")){hydrateRoot(t,_jsx(RedoclyOpenAPIDocs,{store:e}))}export function init(e,t={},r=querySelector("redoc")){if(null===r)throw new Error('"element" argument is not provided and <redoc> tag is not found on the page');let o,i;"string"==typeof e?o=e:"object"==typeof e&&(i=e);createRoot(r).render(createElement(RedoclyOpenAPIDocsStandalone,{definition:i,definitionUrl:o,options:Object.assign(Object.assign({},t),parseOptionsFromElement(r))},["Loading..."]))}export function setPublicPath(e){__webpack_public_path__=e}export const version=__REDOCLY_API_REFERENCE_VERSION__;export const revision=__REDOCLY_API_REFERENCE_REVISION__;function autoInit(){const e=querySelector("redoc");if(!e)return;const t=e.getAttribute("spec-url");t&&init(t,{},e)}IS_BROWSER&&setPublicPath(__dirname),autoInit();
+//# sourceMappingURL=standalone.js.map

package/lib-esm/types/app.d.ts

@@ -0,0 +1,6 @@
+export type RouterType = 'history' | 'memory' | 'hash';
+export type MenuLink = {
+    id: string;
+    href: string;
+    name: string;
+};

package/lib-esm/types/app.js

@@ -0,0 +1,2 @@
+export{};
+//# sourceMappingURL=app.js.map

package/lib-esm/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './open-api';
+export * from './security';
+export * from './app';

package/lib-esm/types/index.js

@@ -0,0 +1,2 @@
+export*from"./open-api";export*from"./security";export*from"./app";
+//# sourceMappingURL=index.js.map

package/lib-esm/types/open-api.d.ts

@@ -0,0 +1,368 @@
+import type { Sample } from '../models';
+export interface OpenAPIDefinition {
+    openapi: string;
+    info: OpenAPIInfo;
+    servers?: OpenAPIServer[];
+    paths: OpenAPIPaths;
+    components?: OpenAPIComponents;
+    security?: OpenAPISecurityRequirement[];
+    tags?: OpenAPITag[];
+    externalDocs?: OpenAPIExternalDocumentation;
+    webhooks?: OpenAPIPaths;
+    'x-webhooks'?: OpenAPIPaths;
+    'x-tagGroups'?: Array<{
+        name: string;
+        tags: Array<string>;
+    }>;
+    'x-feedback'?: any;
+}
+export interface OpenAPIInfo extends ParsedDescriptionWithSummary {
+    title: string;
+    version: string;
+    description?: string;
+    summary?: string;
+    termsOfService?: string;
+    contact?: OpenAPIContact;
+    license?: OpenAPILicense;
+    externalDocs?: OpenAPIExternalDocumentation;
+    'x-logo'?: XLogo;
+    'x-metadata'?: XMetadata;
+    'x-seo'?: XSEO;
+}
+export interface XLogo {
+    url?: string;
+    backgroundColor?: string;
+    altText?: string;
+    href?: string;
+}
+export interface XMetadata {
+    apiId?: string;
+    [key: string]: unknown;
+}
+export interface XSEO {
+    title?: string;
+}
+export interface OpenAPIServer extends ParsedDescription {
+    url: string;
+    description?: string;
+    variables?: OpenAPIServerVariables;
+}
+export interface OpenAPIServerVariables {
+    [name: string]: OpenAPIServerVariable;
+}
+export interface OpenAPIServerVariable extends ParsedDescription {
+    enum?: string[];
+    default: string;
+    description?: string;
+}
+export interface OpenAPIPaths {
+    [path: string]: OpenAPIPath;
+}
+export interface OpenAPIRef extends ParsedDescriptionWithSummary {
+    $ref: string;
+    'x-refsStack'?: string[];
+    summary?: string;
+    description?: string;
+}
+export type Referenced<T> = T | OpenAPIRef;
+export interface OpenAPIPath extends Partial<OpenAPIRef>, ParsedDescriptionWithSummary {
+    summary?: string;
+    description?: string;
+    get?: OpenAPIOperation;
+    put?: OpenAPIOperation;
+    post?: OpenAPIOperation;
+    delete?: OpenAPIOperation;
+    options?: OpenAPIOperation;
+    head?: OpenAPIOperation;
+    patch?: OpenAPIOperation;
+    trace?: OpenAPIOperation;
+    servers?: OpenAPIServer[];
+    parameters?: Array<Referenced<OpenAPIParameter>>;
+}
+export interface OpenAPIXCodeSample extends Sample {
+    source: string;
+}
+export interface OpenAPIXBadges {
+    name: string;
+    color?: string;
+    position?: 'before' | 'after';
+}
+export interface OpenAPIOperation extends ParsedDescriptionWithSummary {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: OpenAPIExternalDocumentation;
+    operationId?: string;
+    parameters?: Array<Referenced<OpenAPIParameter>>;
+    requestBody?: Referenced<OpenAPIRequestBody>;
+    responses: OpenAPIResponses;
+    callbacks?: {
+        [name: string]: Referenced<OpenAPICallback>;
+    };
+    deprecated?: boolean;
+    security?: OpenAPISecurityRequirement[];
+    servers?: OpenAPIServer[];
+    'x-codeSamples'?: OpenAPIXCodeSample[];
+    'x-badges'?: OpenAPIXBadges[];
+    'x-hideReplay'?: boolean;
+}
+export interface OpenAPIParameter extends ParsedDescription {
+    name: string;
+    in?: OpenAPIParameterLocation;
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: OpenAPIParameterStyle;
+    explode?: boolean;
+    allowReserved?: boolean;
+    schema?: Referenced<OpenAPISchema>;
+    example?: any;
+    examples?: {
+        [media: string]: Referenced<OpenAPIExample>;
+    };
+    content?: {
+        [media: string]: OpenAPIMediaType;
+    };
+    encoding?: Record<string, OpenAPIEncoding>;
+    const?: any;
+}
+export interface OpenAPIExample extends ParsedDescriptionWithSummary {
+    value: any;
+    summary?: string;
+    description?: string;
+    externalValue?: string;
+}
+export interface XMLObject {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+}
+export interface OpenAPISchema extends ParsedDescription {
+    $ref?: string;
+    type?: string | string[];
+    properties?: {
+        [name: string]: OpenAPISchema;
+    };
+    patternProperties?: {
+        [name: string]: OpenAPISchema;
+    };
+    additionalProperties?: boolean | OpenAPISchema;
+    unevaluatedProperties?: boolean | OpenAPISchema;
+    description?: string;
+    default?: any;
+    items?: OpenAPISchema | OpenAPISchema[] | boolean;
+    required?: string[];
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    deprecated?: boolean;
+    format?: string;
+    externalDocs?: OpenAPIExternalDocumentation;
+    discriminator?: OpenAPIDiscriminator;
+    nullable?: boolean;
+    oneOf?: OpenAPISchema[];
+    anyOf?: OpenAPISchema[];
+    allOf?: OpenAPISchema[];
+    not?: OpenAPISchema;
+    title?: string;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean | number;
+    minimum?: number;
+    exclusiveMinimum?: boolean | number;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    enum?: any[];
+    example?: any;
+    examples?: any[];
+    const?: string;
+    contentEncoding?: string;
+    contentMediaType?: string;
+    if?: OpenAPISchema;
+    else?: OpenAPISchema;
+    then?: OpenAPISchema;
+    prefixItems?: OpenAPISchema[];
+    additionalItems?: OpenAPISchema | boolean;
+    xml?: XMLObject;
+}
+export interface OpenAPIDiscriminator {
+    propertyName: string;
+    mapping?: {
+        [name: string]: string;
+    };
+    'x-explicitMappingOnly'?: boolean;
+}
+export interface OpenAPIMediaType {
+    schema?: Referenced<OpenAPISchema>;
+    example?: any;
+    examples?: {
+        [name: string]: Referenced<OpenAPIExample>;
+    };
+    encoding?: {
+        [field: string]: OpenAPIEncoding;
+    };
+}
+export interface OpenAPIEncoding {
+    contentType: string;
+    headers?: {
+        [name: string]: Referenced<OpenAPIHeader>;
+    };
+    style: OpenAPIParameterStyle;
+    explode: boolean;
+    allowReserved: boolean;
+}
+export type OpenAPIParameterLocation = 'query' | 'header' | 'path' | 'cookie';
+export type OpenAPIParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+export interface OpenAPIRequestBody extends ParsedDescription {
+    description?: string;
+    required?: boolean;
+    content: {
+        [mime: string]: OpenAPIMediaType;
+    };
+    'x-examples'?: {
+        [mime: string]: {
+            [name: string]: Referenced<OpenAPIExample>;
+        };
+    };
+    'x-example'?: {
+        [mime: string]: any;
+    };
+}
+export interface OpenAPIResponses {
+    [code: string]: OpenAPIResponse;
+}
+export interface OpenAPIResponse extends ParsedDescription {
+    description?: string;
+    headers?: {
+        [name: string]: Referenced<OpenAPIHeader>;
+    };
+    content?: {
+        [mime: string]: OpenAPIMediaType;
+    };
+    links?: {
+        [name: string]: Referenced<OpenAPILink>;
+    };
+    'x-examples'?: {
+        [mime: string]: {
+            [name: string]: Referenced<OpenAPIExample>;
+        };
+    };
+    'x-example'?: {
+        [mime: string]: any;
+    };
+}
+export interface OpenAPILink {
+    $ref?: string;
+}
+export type OpenAPIHeader = Omit<OpenAPIParameter, 'in' | 'name'>;
+export interface OpenAPICallback {
+    [name: string]: OpenAPIPath;
+}
+export interface OpenAPIComponents {
+    schemas?: {
+        [name: string]: Referenced<OpenAPISchema>;
+    };
+    responses?: {
+        [name: string]: Referenced<OpenAPIResponse>;
+    };
+    parameters?: {
+        [name: string]: Referenced<OpenAPIParameter>;
+    };
+    examples?: {
+        [name: string]: Referenced<OpenAPIExample>;
+    };
+    requestBodies?: {
+        [name: string]: Referenced<OpenAPIRequestBody>;
+    };
+    headers?: {
+        [name: string]: Referenced<OpenAPIHeader>;
+    };
+    securitySchemes?: {
+        [name: string]: Referenced<OpenAPISecurityScheme>;
+    };
+    links?: {
+        [name: string]: Referenced<OpenAPILink>;
+    };
+    callbacks?: {
+        [name: string]: Referenced<OpenAPICallback>;
+    };
+}
+export interface OpenAPISecurityRequirement {
+    [name: string]: string[];
+}
+export interface OpenAPISecurityScheme extends ParsedDescription {
+    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+    description?: string;
+    name?: string;
+    in?: 'query' | 'header' | 'cookie';
+    scheme?: string;
+    bearerFormat: string;
+    'x-defaultClientId'?: string;
+    flows: {
+        implicit?: {
+            refreshUrl?: string;
+            scopes: Record<string, string>;
+            authorizationUrl: string;
+            'x-defaultClientId'?: string;
+        };
+        password?: {
+            refreshUrl?: string;
+            scopes: Record<string, string>;
+            tokenUrl: string;
+            'x-defaultClientId'?: string;
+        };
+        clientCredentials?: {
+            refreshUrl?: string;
+            scopes: Record<string, string>;
+            tokenUrl: string;
+            'x-defaultClientId'?: string;
+            'x-assertionType'?: 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer';
+        };
+        authorizationCode?: {
+            refreshUrl?: string;
+            scopes: Record<string, string>;
+            authorizationUrl: string;
+            tokenUrl: string;
+            'x-defaultClientId'?: string;
+        };
+    };
+    openIdConnectUrl?: string;
+}
+export interface OpenAPITag extends ParsedDescription {
+    name: string;
+    description?: string;
+    externalDocs?: OpenAPIExternalDocumentation;
+    'x-displayName'?: string;
+    'x-rbac'?: Record<string, unknown>;
+}
+export interface OpenAPIExternalDocumentation extends ParsedDescription {
+    description?: string;
+    url: string;
+}
+export interface OpenAPIContact {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+export interface OpenAPILicense {
+    name: string;
+    url?: string;
+    identifier?: string;
+}
+export interface ParsedDocument extends OpenAPIDefinition {
+    swagger: unknown;
+}
+export interface ParsedDescription {
+    'x-parsed-md-description'?: GenericObject;
+}
+export interface ParsedDescriptionWithSummary extends ParsedDescription {
+    'x-parsed-md-summary'?: GenericObject;
+}

package/lib-esm/types/open-api.js

@@ -0,0 +1,2 @@
+export{};
+//# sourceMappingURL=open-api.js.map

package/lib-esm/types/security.d.ts

@@ -0,0 +1,11 @@
+export type SecurityDetails = {
+    password?: string;
+    username?: string;
+    token?: {
+        token_type?: string;
+        access_token: string;
+    };
+    client_id?: string;
+    client_secret?: string;
+    scopes?: string;
+};

package/lib-esm/types/security.js

@@ -0,0 +1,2 @@
+export{};
+//# sourceMappingURL=security.js.map

package/lib-esm/utils/JsonPointer.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Wrapper for JsonPointer. Provides common operations
+ */
+export declare class JsonPointer {
+    /**
+     * returns last JsonPointer token
+     * if level > 1 returns levels last (second last/third last)
+     * @example
+     * // returns subpath
+     * JsonPointerHelper.baseName('/path/0/subpath')
+     * // returns foo
+     * JsonPointerHelper.baseName('/path/foo/subpath', 2)
+     */
+    static baseName(pointer?: string, level?: number): string;
+    /**
+     * returns dirname of pointer
+     * if level > 1 returns corresponding dirname in the hierarchy
+     * @example
+     * // returns /path/0
+     * JsonPointerHelper.dirName('/path/0/subpath')
+     * // returns /path
+     * JsonPointerHelper.dirName('/path/foo/subpath', 2)
+     */
+    static dirName(pointer: string, level?: number): string;
+    /**
+     * returns relative path tokens
+     * @example
+     * // returns ['subpath']
+     * JsonPointerHelper.relative('/path/0', '/path/0/subpath')
+     * // returns ['foo', 'subpath']
+     * JsonPointerHelper.relative('/path', '/path/foo/subpath')
+     */
+    static relative(from: string, to: string): string[];
+    /**
+     * overridden JsonPointer original parse to take care of prefixing '#' symbol
+     * that is not valid JsonPointer
+     */
+    static parse(pointer?: string): string[];
+    /**
+     * Creates a JSON pointer path, by joining one or more tokens to a base path.
+     *
+     * @param {string} base - The base path
+     * @param {string|string[]} tokens - The token(s) to append (e.g. ["name", "first"])
+     * @returns {string}
+     */
+    static join(base: string, tokens: string | string[]): string;
+    static get<T>(object: GenericObject, pointer: string): T;
+    static compile(tokens: string[]): string;
+    static escape(pointer: string): string;
+}
+export default JsonPointer;

package/lib-esm/utils/JsonPointer.js

@@ -0,0 +1,2 @@
+"use strict";import JsonPointerLib from"json-pointer";const origParse=JsonPointerLib.parse;export class JsonPointer{static baseName(t="",e=1){const n=JsonPointer.parse(t);return n[n.length-e]}static dirName(t,e=1){const n=JsonPointer.parse(t);return JsonPointerLib.compile(n.slice(0,n.length-e))}static relative(t,e){const n=JsonPointer.parse(t);return JsonPointer.parse(e).slice(n.length)}static parse(t=""){let e=t;return"#"===e.charAt(0)&&(e=e.substring(1)),origParse(e)}static join(t,e){const n=JsonPointer.parse(t).concat(e);return JsonPointerLib.compile(n)}static get(t,e){return JsonPointerLib.get(t,e)}static compile(t){return JsonPointerLib.compile(t)}static escape(t){return JsonPointerLib.escape(t)}}JsonPointerLib.parse=JsonPointer.parse,Object.assign(JsonPointer,JsonPointerLib);export default JsonPointer;
+//# sourceMappingURL=JsonPointer.js.map

package/lib-esm/utils/areArraysEqual.d.ts

@@ -0,0 +1 @@
+export declare function areArraysEqual(arr1: unknown[], arr2: unknown[]): boolean;

package/lib-esm/utils/areArraysEqual.js

@@ -0,0 +1,2 @@
+export function areArraysEqual(e,r){return e.length===r.length&&e.every(((e,n)=>e===r[n]))}
+//# sourceMappingURL=areArraysEqual.js.map

package/lib-esm/utils/argValuesHelpers.d.ts

@@ -0,0 +1,4 @@
+export declare function argValueToBoolean(val?: string | boolean, defaultValue?: boolean): boolean;
+export declare function argValueToNumber(value: number | string | undefined, defaultValue?: number): number;
+export declare function argValueToInt(value: number | string | undefined, defaultValue?: number): number;
+export declare function argValueToExpandLevel(value?: number | string | undefined, defaultValue?: number): number | undefined;

package/lib-esm/utils/argValuesHelpers.js

@@ -0,0 +1,2 @@
+export function argValueToBoolean(e,r){return void 0===e?r||!1:"string"==typeof e?"false"!==e:e}export function argValueToNumber(e,r=0){return"string"==typeof e?parseInt(e,10):"number"==typeof e?e:r}export function argValueToInt(e,r=0){return"string"==typeof e?parseInt(e,10):"number"==typeof e?Math.ceil(e):r}export function argValueToExpandLevel(e,r){return void 0===e?r:"all"===e?1/0:argValueToInt(e,r)}
+//# sourceMappingURL=argValuesHelpers.js.map

package/lib-esm/utils/compose.d.ts

@@ -0,0 +1 @@
+export declare const compose: <T>(fn1: (a: T) => T, ...fns: Array<(a: T) => T>) => (a: T) => T;

package/lib-esm/utils/compose.js

@@ -0,0 +1,2 @@
+export const compose=(e,...o)=>o.reduce(((e,o)=>c=>e(o(c))),e);
+//# sourceMappingURL=compose.js.map