@redocly/openapi-core 1.0.0-beta.100

package/lib/lint.js

@@ -0,0 +1,99 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintConfig = exports.lintDocument = exports.lintFromString = exports.lint = void 0;
+const resolve_1 = require("./resolve");
+const visitors_1 = require("./visitors");
+const oas3_1_1 = require("./types/oas3_1");
+const oas3_1 = require("./types/oas3");
+const oas2_1 = require("./types/oas2");
+const walk_1 = require("./walk");
+const config_1 = require("./config");
+const types_1 = require("./types");
+const ajv_1 = require("./rules/ajv");
+const oas_types_1 = require("./oas-types");
+const redocly_yaml_1 = require("./types/redocly-yaml");
+const spec_1 = require("./rules/common/spec");
+function lint(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { ref, externalRefResolver = new resolve_1.BaseResolver(opts.config.resolve) } = opts;
+        const document = (yield externalRefResolver.resolveDocument(null, ref, true));
+        return lintDocument(Object.assign(Object.assign({ document }, opts), { externalRefResolver, config: opts.config.lint }));
+    });
+}
+exports.lint = lint;
+function lintFromString(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { source, absoluteRef, externalRefResolver = new resolve_1.BaseResolver(opts.config.resolve) } = opts;
+        const document = resolve_1.makeDocumentFromString(source, absoluteRef || '/');
+        return lintDocument(Object.assign(Object.assign({ document }, opts), { externalRefResolver, config: opts.config.lint }));
+    });
+}
+exports.lintFromString = lintFromString;
+function lintDocument(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        ajv_1.releaseAjvInstance(); // FIXME: preprocessors can modify nodes which are then cached to ajv-instance by absolute path
+        const { document, customTypes, externalRefResolver, config } = opts;
+        const oasVersion = oas_types_1.detectOpenAPI(document.parsed);
+        const oasMajorVersion = oas_types_1.openAPIMajor(oasVersion);
+        const rules = config.getRulesForOasVersion(oasMajorVersion);
+        const types = types_1.normalizeTypes(config.extendTypes((customTypes !== null && customTypes !== void 0 ? customTypes : oasMajorVersion === oas_types_1.OasMajorVersion.Version3) ? (oasVersion === oas_types_1.OasVersion.Version3_1 ? oas3_1_1.Oas3_1Types : oas3_1.Oas3Types) : oas2_1.Oas2Types, oasVersion), config);
+        const ctx = {
+            problems: [],
+            oasVersion: oasVersion,
+            visitorsData: {},
+        };
+        const preprocessors = config_1.initRules(rules, config, 'preprocessors', oasVersion);
+        const regularRules = config_1.initRules(rules, config, 'rules', oasVersion);
+        const normalizedVisitors = visitors_1.normalizeVisitors([...preprocessors, ...regularRules], types);
+        const resolvedRefMap = yield resolve_1.resolveDocument({
+            rootDocument: document,
+            rootType: types.DefinitionRoot,
+            externalRefResolver
+        });
+        walk_1.walkDocument({
+            document,
+            rootType: types.DefinitionRoot,
+            normalizedVisitors,
+            resolvedRefMap,
+            ctx,
+        });
+        return ctx.problems.map((problem) => config.addProblemToIgnore(problem));
+    });
+}
+exports.lintDocument = lintDocument;
+function lintConfig(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { document } = opts;
+        const ctx = {
+            problems: [],
+            oasVersion: oas_types_1.OasVersion.Version3_0,
+            visitorsData: {},
+        };
+        const plugins = config_1.resolvePlugins([config_1.defaultPlugin]);
+        const config = new config_1.LintConfig({
+            plugins,
+            rules: { spec: 'error' },
+        });
+        const types = types_1.normalizeTypes(redocly_yaml_1.ConfigTypes, config);
+        const rules = [{ severity: 'error', ruleId: 'spec', visitor: spec_1.OasSpec({ severity: 'error' }) }];
+        const normalizedVisitors = visitors_1.normalizeVisitors(rules, types);
+        walk_1.walkDocument({
+            document,
+            rootType: types.ConfigRoot,
+            normalizedVisitors,
+            resolvedRefMap: new Map(),
+            ctx,
+        });
+        return ctx.problems;
+    });
+}
+exports.lintConfig = lintConfig;

package/lib/oas-types.d.ts

@@ -0,0 +1,19 @@
+import { Oas3Rule, Oas3Preprocessor, Oas2Rule, Oas2Preprocessor } from './visitors';
+export declare type RuleSet<T> = Record<string, T>;
+export declare enum OasVersion {
+    Version2 = "oas2",
+    Version3_0 = "oas3_0",
+    Version3_1 = "oas3_1"
+}
+export declare enum OasMajorVersion {
+    Version2 = "oas2",
+    Version3 = "oas3"
+}
+export declare type Oas3RuleSet = Record<string, Oas3Rule>;
+export declare type Oas2RuleSet = Record<string, Oas2Rule>;
+export declare type Oas3PreprocessorsSet = Record<string, Oas3Preprocessor>;
+export declare type Oas2PreprocessorsSet = Record<string, Oas2Preprocessor>;
+export declare type Oas3DecoratorsSet = Record<string, Oas3Preprocessor>;
+export declare type Oas2DecoratorsSet = Record<string, Oas2Preprocessor>;
+export declare function detectOpenAPI(root: any): OasVersion;
+export declare function openAPIMajor(version: OasVersion): OasMajorVersion;

package/lib/oas-types.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openAPIMajor = exports.detectOpenAPI = exports.OasMajorVersion = exports.OasVersion = void 0;
+var OasVersion;
+(function (OasVersion) {
+    OasVersion["Version2"] = "oas2";
+    OasVersion["Version3_0"] = "oas3_0";
+    OasVersion["Version3_1"] = "oas3_1";
+})(OasVersion = exports.OasVersion || (exports.OasVersion = {}));
+var OasMajorVersion;
+(function (OasMajorVersion) {
+    OasMajorVersion["Version2"] = "oas2";
+    OasMajorVersion["Version3"] = "oas3";
+})(OasMajorVersion = exports.OasMajorVersion || (exports.OasMajorVersion = {}));
+function detectOpenAPI(root) {
+    if (typeof root !== 'object') {
+        throw new Error(`Document must be JSON object, got ${typeof root}`);
+    }
+    if (!(root.openapi || root.swagger)) {
+        throw new Error('This doesn’t look like an OpenAPI document.\n');
+    }
+    if (root.openapi && typeof root.openapi !== 'string') {
+        throw new Error(`Invalid OpenAPI version: should be a string but got "${typeof root.openapi}"`);
+    }
+    if (root.openapi && root.openapi.startsWith('3.0')) {
+        return OasVersion.Version3_0;
+    }
+    if (root.openapi && root.openapi.startsWith('3.1')) {
+        return OasVersion.Version3_1;
+    }
+    if (root.swagger && root.swagger === '2.0') {
+        return OasVersion.Version2;
+    }
+    throw new Error(`Unsupported OpenAPI Version: ${root.openapi || root.swagger}`);
+}
+exports.detectOpenAPI = detectOpenAPI;
+function openAPIMajor(version) {
+    if (version === OasVersion.Version2) {
+        return OasMajorVersion.Version2;
+    }
+    else {
+        return OasMajorVersion.Version3;
+    }
+}
+exports.openAPIMajor = openAPIMajor;

package/lib/redocly/index.d.ts

@@ -0,0 +1,30 @@
+import { RegistryApi } from './registry-api';
+import { RegionalToken, RegionalTokenWithValidity } from './redocly-client-types';
+import type { AccessTokens, Region } from '../config/types';
+export declare class RedoclyClient {
+    private accessTokens;
+    private region;
+    domain: string;
+    registryApi: RegistryApi;
+    constructor(region?: Region);
+    loadRegion(region?: Region): Region;
+    getRegion(): Region;
+    hasTokens(): boolean;
+    hasToken(): boolean;
+    getAuthorizationHeader(): Promise<string | undefined>;
+    setAccessTokens(accessTokens: AccessTokens): void;
+    loadTokens(): void;
+    getAllTokens(): RegionalToken[];
+    getValidTokens(): Promise<RegionalTokenWithValidity[]>;
+    getTokens(): Promise<RegionalTokenWithValidity[]>;
+    isAuthorizedWithRedoclyByRegion(): Promise<boolean>;
+    isAuthorizedWithRedocly(): Promise<boolean>;
+    readCredentialsFile(credentialsPath: string): any;
+    verifyToken(accessToken: string, region: Region, verbose?: boolean): Promise<{
+        viewerId: string;
+        organizations: string[];
+    }>;
+    login(accessToken: string, verbose?: boolean): Promise<void>;
+    logout(): void;
+}
+export declare function isRedoclyRegistryURL(link: string): boolean;

package/lib/redocly/index.js

@@ -0,0 +1,153 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRedoclyRegistryURL = exports.RedoclyClient = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const colorette_1 = require("colorette");
+const registry_api_1 = require("./registry-api");
+const config_1 = require("../config/config");
+const utils_1 = require("../utils");
+const TOKEN_FILENAME = '.redocly-config.json';
+class RedoclyClient {
+    constructor(region) {
+        this.accessTokens = {};
+        this.region = this.loadRegion(region);
+        this.loadTokens();
+        this.domain = region ? config_1.DOMAINS[region] : config_1.env.REDOCLY_DOMAIN || config_1.DOMAINS[config_1.DEFAULT_REGION];
+        config_1.env.REDOCLY_DOMAIN = this.domain; // isRedoclyRegistryURL depends on the value to be set
+        this.registryApi = new registry_api_1.RegistryApi(this.accessTokens, this.region);
+    }
+    loadRegion(region) {
+        if (region && !config_1.DOMAINS[region]) {
+            throw new Error(`Invalid argument: region in config file.\nGiven: ${colorette_1.green(region)}, choices: "us", "eu".`);
+        }
+        if (config_1.env.REDOCLY_DOMAIN) {
+            return (config_1.AVAILABLE_REGIONS.find((region) => config_1.DOMAINS[region] === config_1.env.REDOCLY_DOMAIN) || config_1.DEFAULT_REGION);
+        }
+        return region || config_1.DEFAULT_REGION;
+    }
+    getRegion() {
+        return this.region;
+    }
+    hasTokens() {
+        return utils_1.isNotEmptyObject(this.accessTokens);
+    }
+    // <backward compatibility: old versions of portal>
+    hasToken() {
+        return !!this.accessTokens[this.region];
+    }
+    getAuthorizationHeader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.accessTokens[this.region];
+        });
+    }
+    // </backward compatibility: portal>
+    setAccessTokens(accessTokens) {
+        this.accessTokens = accessTokens;
+    }
+    loadTokens() {
+        const credentialsPath = path_1.resolve(os_1.homedir(), TOKEN_FILENAME);
+        const credentials = this.readCredentialsFile(credentialsPath);
+        if (utils_1.isNotEmptyObject(credentials)) {
+            this.setAccessTokens(Object.assign(Object.assign({}, credentials), (credentials.token &&
+                !credentials[this.region] && {
+                [this.region]: credentials.token,
+            })));
+        }
+        if (config_1.env.REDOCLY_AUTHORIZATION) {
+            this.setAccessTokens(Object.assign(Object.assign({}, this.accessTokens), { [this.region]: config_1.env.REDOCLY_AUTHORIZATION }));
+        }
+    }
+    getAllTokens() {
+        return Object.entries(this.accessTokens)
+            .filter(([region]) => config_1.AVAILABLE_REGIONS.includes(region))
+            .map(([region, token]) => ({ region, token }));
+    }
+    getValidTokens() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allTokens = this.getAllTokens();
+            const verifiedTokens = yield Promise.allSettled(allTokens.map(({ token, region }) => this.verifyToken(token, region)));
+            return allTokens
+                .filter((_, index) => verifiedTokens[index].status === 'fulfilled')
+                .map(({ token, region }) => ({ token, region, valid: true }));
+        });
+    }
+    getTokens() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.hasTokens() ? yield this.getValidTokens() : [];
+        });
+    }
+    isAuthorizedWithRedoclyByRegion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.hasTokens()) {
+                return false;
+            }
+            const accessToken = this.accessTokens[this.region];
+            if (!accessToken) {
+                return false;
+            }
+            try {
+                yield this.verifyToken(accessToken, this.region);
+                return true;
+            }
+            catch (err) {
+                return false;
+            }
+        });
+    }
+    isAuthorizedWithRedocly() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.hasTokens() && utils_1.isNotEmptyObject(yield this.getValidTokens());
+        });
+    }
+    readCredentialsFile(credentialsPath) {
+        return fs_1.existsSync(credentialsPath) ? JSON.parse(fs_1.readFileSync(credentialsPath, 'utf-8')) : {};
+    }
+    verifyToken(accessToken, region, verbose = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.registryApi.authStatus(accessToken, region, verbose);
+        });
+    }
+    login(accessToken, verbose = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const credentialsPath = path_1.resolve(os_1.homedir(), TOKEN_FILENAME);
+            try {
+                yield this.verifyToken(accessToken, this.region, verbose);
+            }
+            catch (err) {
+                throw new Error('Authorization failed. Please check if you entered a valid API key.');
+            }
+            const credentials = Object.assign(Object.assign({}, this.readCredentialsFile(credentialsPath)), { [this.region]: accessToken, token: accessToken });
+            this.accessTokens = credentials;
+            this.registryApi.setAccessTokens(credentials);
+            fs_1.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2));
+        });
+    }
+    logout() {
+        const credentialsPath = path_1.resolve(os_1.homedir(), TOKEN_FILENAME);
+        if (fs_1.existsSync(credentialsPath)) {
+            fs_1.unlinkSync(credentialsPath);
+        }
+    }
+}
+exports.RedoclyClient = RedoclyClient;
+function isRedoclyRegistryURL(link) {
+    const domain = config_1.env.REDOCLY_DOMAIN || config_1.DOMAINS[config_1.DEFAULT_REGION];
+    const legacyDomain = domain === 'redocly.com' ? 'redoc.ly' : domain;
+    if (!link.startsWith(`https://api.${domain}/registry/`) &&
+        !link.startsWith(`https://api.${legacyDomain}/registry/`)) {
+        return false;
+    }
+    return true;
+}
+exports.isRedoclyRegistryURL = isRedoclyRegistryURL;

package/lib/redocly/redocly-client-types.d.ts

@@ -0,0 +1,8 @@
+import type { Region } from '../config/types';
+export interface RegionalToken {
+    region: Region;
+    token: string;
+}
+export interface RegionalTokenWithValidity extends RegionalToken {
+    valid: boolean;
+}

package/lib/redocly/redocly-client-types.js

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

package/lib/redocly/registry-api-types.d.ts

@@ -0,0 +1,29 @@
+export declare namespace RegistryApiTypes {
+    interface VersionParams {
+        organizationId: string;
+        name: string;
+        version: string;
+    }
+    export interface PrepareFileuploadParams extends VersionParams {
+        filesHash: string;
+        filename: string;
+        isUpsert?: boolean;
+    }
+    export interface PushApiParams extends VersionParams {
+        rootFilePath: string;
+        filePaths: string[];
+        branch?: string;
+        isUpsert?: boolean;
+        isPublic?: boolean;
+    }
+    export interface PrepareFileuploadOKResponse {
+        filePath: string;
+        signedUploadUrl: string;
+    }
+    export interface NotFoundProblemResponse {
+        status: 404;
+        title: 'Not Found';
+        code: 'ORGANIZATION_NOT_FOUND' | 'API_VERSION_NOT_FOUND';
+    }
+    export {};
+}

package/lib/redocly/registry-api-types.js

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

package/lib/redocly/registry-api.d.ts

@@ -0,0 +1,17 @@
+import { RegistryApiTypes } from './registry-api-types';
+import type { AccessTokens, Region } from '../config/types';
+export declare class RegistryApi {
+    private accessTokens;
+    private region;
+    constructor(accessTokens: AccessTokens, region: Region);
+    get accessToken(): string | false | undefined;
+    getBaseUrl(region?: Region): string;
+    setAccessTokens(accessTokens: AccessTokens): this;
+    private request;
+    authStatus(accessToken: string, region: Region, verbose?: boolean): Promise<{
+        viewerId: string;
+        organizations: string[];
+    }>;
+    prepareFileUpload({ organizationId, name, version, filesHash, filename, isUpsert, }: RegistryApiTypes.PrepareFileuploadParams): Promise<RegistryApiTypes.PrepareFileuploadOKResponse>;
+    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, isPublic, }: RegistryApiTypes.PushApiParams): Promise<void>;
+}

package/lib/redocly/registry-api.js

@@ -0,0 +1,106 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryApi = void 0;
+const node_fetch_1 = require("node-fetch");
+const config_1 = require("../config/config");
+const utils_1 = require("../utils");
+const version = require('../../package.json').version;
+class RegistryApi {
+    constructor(accessTokens, region) {
+        this.accessTokens = accessTokens;
+        this.region = region;
+    }
+    get accessToken() {
+        return utils_1.isNotEmptyObject(this.accessTokens) && this.accessTokens[this.region];
+    }
+    getBaseUrl(region = config_1.DEFAULT_REGION) {
+        return `https://api.${config_1.DOMAINS[region]}/registry`;
+    }
+    setAccessTokens(accessTokens) {
+        this.accessTokens = accessTokens;
+        return this;
+    }
+    request(path = '', options = {}, region) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = Object.assign({}, options.headers || {}, { 'x-redocly-cli-version': version });
+            if (!headers.hasOwnProperty('authorization')) {
+                throw new Error('Unauthorized');
+            }
+            const response = yield node_fetch_1.default(`${this.getBaseUrl(region)}${path}`, Object.assign({}, options, { headers }));
+            if (response.status === 401) {
+                throw new Error('Unauthorized');
+            }
+            if (response.status === 404) {
+                const body = yield response.json();
+                throw new Error(body.code);
+            }
+            return response;
+        });
+    }
+    authStatus(accessToken, region, verbose = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.request('', { headers: { authorization: accessToken } }, region);
+                return yield response.json();
+            }
+            catch (error) {
+                if (verbose) {
+                    console.log(error);
+                }
+                throw error;
+            }
+        });
+    }
+    prepareFileUpload({ organizationId, name, version, filesHash, filename, isUpsert, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.request(`/${organizationId}/${name}/${version}/prepare-file-upload`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    authorization: this.accessToken,
+                },
+                body: JSON.stringify({
+                    filesHash,
+                    filename,
+                    isUpsert,
+                }),
+            }, this.region);
+            if (response.ok) {
+                return response.json();
+            }
+            throw new Error('Could not prepare file upload');
+        });
+    }
+    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, isPublic, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.request(`/${organizationId}/${name}/${version}`, {
+                method: 'PUT',
+                headers: {
+                    'content-type': 'application/json',
+                    authorization: this.accessToken,
+                },
+                body: JSON.stringify({
+                    rootFilePath,
+                    filePaths,
+                    branch,
+                    isUpsert,
+                    isPublic,
+                }),
+            }, this.region);
+            if (response.ok) {
+                return;
+            }
+            throw new Error('Could not push api');
+        });
+    }
+}
+exports.RegistryApi = RegistryApi;

package/lib/ref-utils.d.ts

@@ -0,0 +1,25 @@
+import { Source } from './resolve';
+import { OasRef } from './typings/openapi';
+export declare function joinPointer(base: string, key: string | number): string;
+export declare function isRef(node: any): node is OasRef;
+export declare class Location {
+    source: Source;
+    pointer: string;
+    constructor(source: Source, pointer: string);
+    child(components: (string | number)[] | string | number): Location;
+    key(): this & {
+        reportOnKey: boolean;
+    };
+    get absolutePointer(): string;
+}
+export declare function unescapePointer(fragment: string): string;
+export declare function escapePointer<T extends string | number>(fragment: T): T;
+export declare function parseRef(ref: string): {
+    uri: string | null;
+    pointer: string[];
+};
+export declare function parsePointer(pointer: string): string[];
+export declare function pointerBaseName(pointer: string): string;
+export declare function refBaseName(ref: string): string;
+export declare function isAbsoluteUrl(ref: string): boolean;
+export declare function isMappingRef(mapping: string): boolean;

package/lib/ref-utils.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMappingRef = exports.isAbsoluteUrl = exports.refBaseName = exports.pointerBaseName = exports.parsePointer = exports.parseRef = exports.escapePointer = exports.unescapePointer = exports.Location = exports.isRef = exports.joinPointer = void 0;
+function joinPointer(base, key) {
+    if (base === '')
+        base = '#/';
+    return base[base.length - 1] === '/' ? base + key : base + '/' + key;
+}
+exports.joinPointer = joinPointer;
+function isRef(node) {
+    return node && typeof node.$ref === 'string';
+}
+exports.isRef = isRef;
+class Location {
+    constructor(source, pointer) {
+        this.source = source;
+        this.pointer = pointer;
+    }
+    child(components) {
+        return new Location(this.source, joinPointer(this.pointer, (Array.isArray(components) ? components : [components]).map(escapePointer).join('/')));
+    }
+    key() {
+        return Object.assign(Object.assign({}, this), { reportOnKey: true });
+    }
+    get absolutePointer() {
+        return this.source.absoluteRef + (this.pointer === '#/' ? '' : this.pointer);
+    }
+}
+exports.Location = Location;
+function unescapePointer(fragment) {
+    return decodeURIComponent(fragment.replace(/~1/g, '/').replace(/~0/g, '~'));
+}
+exports.unescapePointer = unescapePointer;
+function escapePointer(fragment) {
+    if (typeof fragment === 'number')
+        return fragment;
+    return fragment.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+exports.escapePointer = escapePointer;
+function parseRef(ref) {
+    const [uri, pointer] = ref.split('#/');
+    return {
+        uri: uri || null,
+        pointer: pointer ? pointer.split('/').map(unescapePointer).filter(Boolean) : [],
+    };
+}
+exports.parseRef = parseRef;
+function parsePointer(pointer) {
+    return pointer.substr(2).split('/').map(unescapePointer);
+}
+exports.parsePointer = parsePointer;
+function pointerBaseName(pointer) {
+    const parts = pointer.split('/');
+    return parts[parts.length - 1];
+}
+exports.pointerBaseName = pointerBaseName;
+function refBaseName(ref) {
+    const parts = ref.split(/[\/\\]/); // split by '\' and '/'
+    return parts[parts.length - 1].replace(/\.[^.]+$/, ''); // replace extension with empty string
+}
+exports.refBaseName = refBaseName;
+function isAbsoluteUrl(ref) {
+    return ref.startsWith('http://') || ref.startsWith('https://');
+}
+exports.isAbsoluteUrl = isAbsoluteUrl;
+function isMappingRef(mapping) {
+    // TODO: proper detection of mapping refs
+    return (mapping.startsWith('#') ||
+        mapping.startsWith('https://') ||
+        mapping.startsWith('http://') ||
+        mapping.startsWith('./') ||
+        mapping.startsWith('../') ||
+        mapping.indexOf('/') > -1);
+}
+exports.isMappingRef = isMappingRef;