@apidevtools/json-schema-ref-parser 11.4.0 → 11.4.2

package/dist/lib/index.d.ts

@@ -1,15 +1,8 @@
 import $Refs from "./refs.js";
-import { JSONParserError, InvalidPointerError, MissingPointerError, ResolverError, ParserError, UnmatchedParserError, UnmatchedResolverError } from "./util/errors.js";
+import { JSONParserError, InvalidPointerError, MissingPointerError, ResolverError, ParserError, UnmatchedParserError, UnmatchedResolverError, isHandledError, JSONParserErrorGroup } from "./util/errors.js";
 import type { ParserOptions } from "./options.js";
 import type { $RefsCallback, JSONSchema, SchemaCallback } from "./types/index.js";
-export { JSONParserError };
-export { InvalidPointerError };
-export { MissingPointerError };
-export { ResolverError };
-export { ParserError };
-export { UnmatchedParserError };
-export { UnmatchedResolverError };
-type RefParserSchema = string | JSONSchema;
+export type RefParserSchema = string | JSONSchema;
 /**
  * This class parses a JSON schema, builds a map of its JSON references and their resolved values,
  * and provides methods for traversing, manipulating, and dereferencing those references.
@@ -88,17 +81,6 @@ export declare class $RefParser {
     static resolve(schema: RefParserSchema, options: ParserOptions, callback: $RefsCallback): Promise<void>;
     static resolve(baseUrl: string, schema: RefParserSchema, options: ParserOptions): Promise<$Refs>;
     static resolve(baseUrl: string, schema: RefParserSchema, options: ParserOptions, callback: $RefsCallback): Promise<void>;
-    /**
-     * Parses the given JSON schema, resolves any JSON references, and bundles all external references
-     * into the main JSON schema. This produces a JSON schema that only has *internal* references,
-     * not any *external* references.
-     *
-     * @param [path] - The file path or URL of the JSON schema
-     * @param [schema] - A JSON schema object. This object will be used instead of reading from `path`.
-     * @param [options] - Options that determine how the schema is parsed, resolved, and dereferenced
-     * @param [callback] - An error-first callback. The second parameter is the bundled JSON schema object
-     * @returns - The returned promise resolves with the bundled JSON schema object.
-     */
     /**
      * Bundles all referenced files/URLs into a single schema that only has internal `$ref` pointers. This lets you split-up your schema however you want while you're building it, but easily combine all those files together when it's time to package or distribute the schema to other people. The resulting schema size will be small, since it will still contain internal JSON references rather than being fully-dereferenced.
      *
@@ -116,17 +98,6 @@ export declare class $RefParser {
     static bundle(schema: RefParserSchema, options: ParserOptions, callback: SchemaCallback): Promise<void>;
     static bundle(baseUrl: string, schema: RefParserSchema, options: ParserOptions): Promise<JSONSchema>;
     static bundle(baseUrl: string, schema: RefParserSchema, options: ParserOptions, callback: SchemaCallback): Promise<JSONSchema>;
-    /**
-     * Parses the given JSON schema, resolves any JSON references, and bundles all external references
-     * into the main JSON schema. This produces a JSON schema that only has *internal* references,
-     * not any *external* references.
-     *
-     * @param [path] - The file path or URL of the JSON schema
-     * @param [schema] - A JSON schema object. This object will be used instead of reading from `path`.
-     * @param [options] - Options that determine how the schema is parsed, resolved, and dereferenced
-     * @param [callback] - An error-first callback. The second parameter is the bundled JSON schema object
-     * @returns - The returned promise resolves with the bundled JSON schema object.
-     */
     /**
      * Bundles all referenced files/URLs into a single schema that only has internal `$ref` pointers. This lets you split-up your schema however you want while you're building it, but easily combine all those files together when it's time to package or distribute the schema to other people. The resulting schema size will be small, since it will still contain internal JSON references rather than being fully-dereferenced.
      *
@@ -144,16 +115,6 @@ export declare class $RefParser {
     bundle(schema: RefParserSchema, options: ParserOptions, callback: SchemaCallback): Promise<void>;
     bundle(baseUrl: string, schema: RefParserSchema, options: ParserOptions): Promise<JSONSchema>;
     bundle(baseUrl: string, schema: RefParserSchema, options: ParserOptions, callback: SchemaCallback): Promise<void>;
-    /**
-     * Parses the given JSON schema, resolves any JSON references, and dereferences the JSON schema.
-     * That is, all JSON references are replaced with their resolved values.
-     *
-     * @param [path] - The file path or URL of the JSON schema
-     * @param [schema] - A JSON schema object. This object will be used instead of reading from `path`.
-     * @param [options] - Options that determine how the schema is parsed, resolved, and dereferenced
-     * @param [callback] - An error-first callback. The second parameter is the dereferenced JSON schema object
-     * @returns - The returned promise resolves with the dereferenced JSON schema object.
-     */
     /**
      * Dereferences all `$ref` pointers in the JSON Schema, replacing each reference with its resolved value. This results in a schema object that does not contain any `$ref` pointers. Instead, it's a normal JavaScript object tree that can easily be crawled and used just like any other JavaScript object. This is great for programmatic usage, especially when using tools that don't understand JSON references.
      *
@@ -171,16 +132,6 @@ export declare class $RefParser {
     static dereference(schema: RefParserSchema, options: ParserOptions, callback: SchemaCallback): Promise<void>;
     static dereference(baseUrl: string, schema: RefParserSchema, options: ParserOptions): Promise<JSONSchema>;
     static dereference(baseUrl: string, schema: RefParserSchema, options: ParserOptions, callback: SchemaCallback): Promise<void>;
-    /**
-     * Parses the given JSON schema, resolves any JSON references, and dereferences the JSON schema.
-     * That is, all JSON references are replaced with their resolved values.
-     *
-     * @param [path] - The file path or URL of the JSON schema
-     * @param [schema] - A JSON schema object. This object will be used instead of reading from `path`.
-     * @param [options] - Options that determine how the schema is parsed, resolved, and dereferenced
-     * @param [callback] - An error-first callback. The second parameter is the dereferenced JSON schema object
-     * @returns - The returned promise resolves with the dereferenced JSON schema object.
-     */
     /**
      * Dereferences all `$ref` pointers in the JSON Schema, replacing each reference with its resolved value. This results in a schema object that does not contain any `$ref` pointers. Instead, it's a normal JavaScript object tree that can easily be crawled and used just like any other JavaScript object. This is great for programmatic usage, especially when using tools that don't understand JSON references.
      *
@@ -204,3 +155,4 @@ export declare const parse: typeof $RefParser.parse;
 export declare const resolve: typeof $RefParser.resolve;
 export declare const bundle: typeof $RefParser.bundle;
 export declare const dereference: typeof $RefParser.dereference;
+export { UnmatchedResolverError, JSONParserError, JSONSchema, InvalidPointerError, MissingPointerError, ResolverError, ParserError, UnmatchedParserError, ParserOptions, $RefsCallback, isHandledError, JSONParserErrorGroup, SchemaCallback, };

package/dist/lib/index.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dereference = exports.bundle = exports.resolve = exports.parse = exports.$RefParser = exports.UnmatchedResolverError = exports.UnmatchedParserError = exports.ParserError = exports.ResolverError = exports.MissingPointerError = exports.InvalidPointerError = exports.JSONParserError = void 0;
+exports.JSONParserErrorGroup = exports.isHandledError = exports.UnmatchedParserError = exports.ParserError = exports.ResolverError = exports.MissingPointerError = exports.InvalidPointerError = exports.JSONParserError = exports.UnmatchedResolverError = exports.dereference = exports.bundle = exports.resolve = exports.parse = exports.$RefParser = void 0;
 const refs_js_1 = __importDefault(require("./refs.js"));
 const parse_js_1 = __importDefault(require("./parse.js"));
 const normalize_args_js_1 = __importDefault(require("./normalize-args.js"));
@@ -42,6 +42,8 @@ Object.defineProperty(exports, "ResolverError", { enumerable: true, get: functio
 Object.defineProperty(exports, "ParserError", { enumerable: true, get: function () { return errors_js_1.ParserError; } });
 Object.defineProperty(exports, "UnmatchedParserError", { enumerable: true, get: function () { return errors_js_1.UnmatchedParserError; } });
 Object.defineProperty(exports, "UnmatchedResolverError", { enumerable: true, get: function () { return errors_js_1.UnmatchedResolverError; } });
+Object.defineProperty(exports, "isHandledError", { enumerable: true, get: function () { return errors_js_1.isHandledError; } });
+Object.defineProperty(exports, "JSONParserErrorGroup", { enumerable: true, get: function () { return errors_js_1.JSONParserErrorGroup; } });
 const ono_1 = require("@jsdevtools/ono");
 const maybe_js_1 = __importDefault(require("./util/maybe.js"));
 /**
@@ -137,19 +139,6 @@ class $RefParser {
         const parser = new $RefParser();
         return parser.parse.apply(parser, arguments);
     }
-    /**
-     * Parses the given JSON schema and resolves any JSON references, including references in
-     * externally-referenced files.
-     *
-     * @param [path] - The file path or URL of the JSON schema
-     * @param [schema] - A JSON schema object. This object will be used instead of reading from `path`.
-     * @param [options] - Options that determine how the schema is parsed and resolved
-     * @param [callback]
-     * - An error-first callback. The second parameter is a {@link $Refs} object containing the resolved JSON references
-     *
-     * @returns
-     * The returned promise resolves with a {@link $Refs} object containing the resolved JSON references
-     */
     async resolve() {
         const args = (0, normalize_args_js_1.default)(arguments);
         try {

package/dist/lib/normalize-args.d.ts

@@ -1,10 +1,13 @@
-export default normalizeArgs;
+import type { JSONSchema, SchemaCallback } from "./types";
+import type $RefParserOptions from "./options";
+export interface NormalizedArguments<T = $RefParserOptions> {
+    path: string;
+    schema: JSONSchema;
+    options: T;
+    callback: SchemaCallback;
+}
 /**
  * Normalizes the given arguments, accounting for optional args.
  */
-declare function normalizeArgs(_args: Partial<IArguments>): {
-    path: string;
-    schema: any;
-    options: any;
-    callback: any;
-};
+export declare function normalizeArgs<T = $RefParserOptions>(_args: Partial<IArguments>): NormalizedArguments<T>;
+export default normalizeArgs;

package/dist/lib/normalize-args.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeArgs = void 0;
 const options_js_1 = require("./options.js");
-exports.default = normalizeArgs;
 /**
  * Normalizes the given arguments, accounting for optional args.
  */
@@ -36,9 +36,9 @@ function normalizeArgs(_args) {
         options = (0, options_js_1.getNewOptions)(options);
     }
     catch (e) {
-        console.log(e);
+        console.error(`JSON Schema Ref Parser: Error normalizing options: ${e}`);
     }
-    if (!options.mutateInputSchema) {
+    if (!options.mutateInputSchema && typeof schema === "object") {
         // Make a deep clone of the schema, so that we don't alter the original object
         schema = JSON.parse(JSON.stringify(schema));
     }
@@ -49,3 +49,5 @@ function normalizeArgs(_args) {
         callback,
     };
 }
+exports.normalizeArgs = normalizeArgs;
+exports.default = normalizeArgs;

package/dist/lib/options.d.ts

@@ -1,5 +1,5 @@
 import type { HTTPResolverOptions, JSONSchemaObject, Plugin, ResolverOptions } from "./types/index.js";
-type DeepPartial<T> = T extends object ? {
+export type DeepPartial<T> = T extends object ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;
 /**
@@ -8,7 +8,7 @@ type DeepPartial<T> = T extends object ? {
  * @param [options] - Overridden options
  * @class
  */
-interface $RefParserOptions {
+export interface $RefParserOptions {
     /**
      * The `parse` options determine how different types of files will be parsed.
      *
@@ -85,7 +85,8 @@ interface $RefParserOptions {
         mutateInputSchema?: boolean;
     };
 }
-export declare const getNewOptions: (options: DeepPartial<$RefParserOptions>) => $RefParserOptions;
+export declare const getJsonSchemaRefParserDefaultOptions: () => $RefParserOptions;
+export declare const getNewOptions: (options: DeepPartial<$RefParserOptions> | undefined) => $RefParserOptions;
 export type Options = $RefParserOptions;
 export type ParserOptions = DeepPartial<$RefParserOptions>;
 export default $RefParserOptions;

package/dist/lib/options.js

@@ -3,14 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNewOptions = void 0;
+exports.getNewOptions = exports.getJsonSchemaRefParserDefaultOptions = void 0;
 const json_js_1 = __importDefault(require("./parsers/json.js"));
 const yaml_js_1 = __importDefault(require("./parsers/yaml.js"));
 const text_js_1 = __importDefault(require("./parsers/text.js"));
 const binary_js_1 = __importDefault(require("./parsers/binary.js"));
 const file_js_1 = __importDefault(require("./resolvers/file.js"));
 const http_js_1 = __importDefault(require("./resolvers/http.js"));
-const getDefaults = () => {
+const getJsonSchemaRefParserDefaultOptions = () => {
     const defaults = {
         /**
          * Determines how different types of files will be parsed.
@@ -74,8 +74,9 @@ const getDefaults = () => {
     };
     return defaults;
 };
+exports.getJsonSchemaRefParserDefaultOptions = getJsonSchemaRefParserDefaultOptions;
 const getNewOptions = (options) => {
-    const newOptions = getDefaults();
+    const newOptions = (0, exports.getJsonSchemaRefParserDefaultOptions)();
     if (options) {
         merge(newOptions, options);
     }

package/dist/lib/types/index.d.ts

@@ -3,7 +3,7 @@ import type { JSONSchema4, JSONSchema4Object, JSONSchema6, JSONSchema6Object, JS
 import type $Refs from "../refs.js";
 export type JSONSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
 export type JSONSchemaObject = JSONSchema4Object | JSONSchema6Object | JSONSchema7Object;
-export type SchemaCallback = (err: Error | null, schema?: JSONSchema | object) => any;
+export type SchemaCallback = (err: Error | null, schema?: JSONSchema | object | null) => any;
 export type $RefsCallback = (err: Error | null, $refs?: $Refs) => any;
 /**
  * See https://apitools.dev/json-schema-ref-parser/docs/options.html

package/lib/index.ts

@@ -21,15 +21,7 @@ import maybe from "./util/maybe.js";
 import type { ParserOptions } from "./options.js";
 import type { $RefsCallback, JSONSchema, SchemaCallback } from "./types/index.js";
 
-export { JSONParserError };
-export { InvalidPointerError };
-export { MissingPointerError };
-export { ResolverError };
-export { ParserError };
-export { UnmatchedParserError };
-export { UnmatchedResolverError };
-
-type RefParserSchema = string | JSONSchema;
+export type RefParserSchema = string | JSONSchema;
 
 /**
  * This class parses a JSON schema, builds a map of its JSON references and their resolved values,
@@ -76,7 +68,6 @@ export class $RefParser {
     options: ParserOptions,
     callback: SchemaCallback,
   ): Promise<void>;
-
   async parse() {
     const args = normalizeArgs(arguments as any);
     let promise;
@@ -187,19 +178,6 @@ export class $RefParser {
     options: ParserOptions,
     callback: $RefsCallback,
   ): Promise<void>;
-  /**
-   * Parses the given JSON schema and resolves any JSON references, including references in
-   * externally-referenced files.
-   *
-   * @param [path] - The file path or URL of the JSON schema
-   * @param [schema] - A JSON schema object. This object will be used instead of reading from `path`.
-   * @param [options] - Options that determine how the schema is parsed and resolved
-   * @param [callback]
-   * - An error-first callback. The second parameter is a {@link $Refs} object containing the resolved JSON references
-   *
-   * @returns
-   * The returned promise resolves with a {@link $Refs} object containing the resolved JSON references
-   */
   async resolve() {
     const args = normalizeArgs(arguments);
 
@@ -240,17 +218,6 @@ export class $RefParser {
     return instance.resolve.apply(instance, arguments as any);
   }
 
-  /**
-   * Parses the given JSON schema, resolves any JSON references, and bundles all external references
-   * into the main JSON schema. This produces a JSON schema that only has *internal* references,
-   * not any *external* references.
-   *
-   * @param [path] - The file path or URL of the JSON schema
-   * @param [schema] - A JSON schema object. This object will be used instead of reading from `path`.
-   * @param [options] - Options that determine how the schema is parsed, resolved, and dereferenced
-   * @param [callback] - An error-first callback. The second parameter is the bundled JSON schema object
-   * @returns - The returned promise resolves with the bundled JSON schema object.
-   */
   /**
    * Bundles all referenced files/URLs into a single schema that only has internal `$ref` pointers. This lets you split-up your schema however you want while you're building it, but easily combine all those files together when it's time to package or distribute the schema to other people. The resulting schema size will be small, since it will still contain internal JSON references rather than being fully-dereferenced.
    *
@@ -278,17 +245,6 @@ export class $RefParser {
     return instance.bundle.apply(instance, arguments as any);
   }
 
-  /**
-   * Parses the given JSON schema, resolves any JSON references, and bundles all external references
-   * into the main JSON schema. This produces a JSON schema that only has *internal* references,
-   * not any *external* references.
-   *
-   * @param [path] - The file path or URL of the JSON schema
-   * @param [schema] - A JSON schema object. This object will be used instead of reading from `path`.
-   * @param [options] - Options that determine how the schema is parsed, resolved, and dereferenced
-   * @param [callback] - An error-first callback. The second parameter is the bundled JSON schema object
-   * @returns - The returned promise resolves with the bundled JSON schema object.
-   */
   /**
    * Bundles all referenced files/URLs into a single schema that only has internal `$ref` pointers. This lets you split-up your schema however you want while you're building it, but easily combine all those files together when it's time to package or distribute the schema to other people. The resulting schema size will be small, since it will still contain internal JSON references rather than being fully-dereferenced.
    *
@@ -323,16 +279,6 @@ export class $RefParser {
     }
   }
 
-  /**
-   * Parses the given JSON schema, resolves any JSON references, and dereferences the JSON schema.
-   * That is, all JSON references are replaced with their resolved values.
-   *
-   * @param [path] - The file path or URL of the JSON schema
-   * @param [schema] - A JSON schema object. This object will be used instead of reading from `path`.
-   * @param [options] - Options that determine how the schema is parsed, resolved, and dereferenced
-   * @param [callback] - An error-first callback. The second parameter is the dereferenced JSON schema object
-   * @returns - The returned promise resolves with the dereferenced JSON schema object.
-   */
   /**
    * Dereferences all `$ref` pointers in the JSON Schema, replacing each reference with its resolved value. This results in a schema object that does not contain any `$ref` pointers. Instead, it's a normal JavaScript object tree that can easily be crawled and used just like any other JavaScript object. This is great for programmatic usage, especially when using tools that don't understand JSON references.
    *
@@ -360,16 +306,6 @@ export class $RefParser {
     return instance.dereference.apply(instance, arguments as any);
   }
 
-  /**
-   * Parses the given JSON schema, resolves any JSON references, and dereferences the JSON schema.
-   * That is, all JSON references are replaced with their resolved values.
-   *
-   * @param [path] - The file path or URL of the JSON schema
-   * @param [schema] - A JSON schema object. This object will be used instead of reading from `path`.
-   * @param [options] - Options that determine how the schema is parsed, resolved, and dereferenced
-   * @param [callback] - An error-first callback. The second parameter is the dereferenced JSON schema object
-   * @returns - The returned promise resolves with the dereferenced JSON schema object.
-   */
   /**
    * Dereferences all `$ref` pointers in the JSON Schema, replacing each reference with its resolved value. This results in a schema object that does not contain any `$ref` pointers. Instead, it's a normal JavaScript object tree that can easily be crawled and used just like any other JavaScript object. This is great for programmatic usage, especially when using tools that don't understand JSON references.
    *
@@ -418,3 +354,19 @@ export const parse = $RefParser.parse;
 export const resolve = $RefParser.resolve;
 export const bundle = $RefParser.bundle;
 export const dereference = $RefParser.dereference;
+
+export {
+  UnmatchedResolverError,
+  JSONParserError,
+  JSONSchema,
+  InvalidPointerError,
+  MissingPointerError,
+  ResolverError,
+  ParserError,
+  UnmatchedParserError,
+  ParserOptions,
+  $RefsCallback,
+  isHandledError,
+  JSONParserErrorGroup,
+  SchemaCallback,
+};

package/lib/normalize-args.ts

@@ -1,11 +1,19 @@
 import { getNewOptions } from "./options.js";
+import type { JSONSchema, SchemaCallback } from "./types";
+import type $RefParserOptions from "./options";
 
-export default normalizeArgs;
-
+// I really dislike this function and the way it's written. It's not clear what it's doing, and it's way too flexible
+// In the future, I'd like to deprecate the api and accept only named parameters in index.ts
+export interface NormalizedArguments<T = $RefParserOptions> {
+  path: string;
+  schema: JSONSchema;
+  options: T;
+  callback: SchemaCallback;
+}
 /**
  * Normalizes the given arguments, accounting for optional args.
  */
-function normalizeArgs(_args: Partial<IArguments>) {
+export function normalizeArgs<T = $RefParserOptions>(_args: Partial<IArguments>): NormalizedArguments<T> {
   let path, schema, options, callback;
   const args = Array.prototype.slice.call(_args) as any[];
 
@@ -36,10 +44,10 @@ function normalizeArgs(_args: Partial<IArguments>) {
   try {
     options = getNewOptions(options);
   } catch (e) {
-    console.log(e);
+    console.error(`JSON Schema Ref Parser: Error normalizing options: ${e}`);
   }
 
-  if (!options.mutateInputSchema) {
+  if (!options.mutateInputSchema && typeof schema === "object") {
     // Make a deep clone of the schema, so that we don't alter the original object
     schema = JSON.parse(JSON.stringify(schema));
   }
@@ -51,3 +59,5 @@ function normalizeArgs(_args: Partial<IArguments>) {
     callback,
   };
 }
+
+export default normalizeArgs;

package/lib/options.ts

@@ -7,7 +7,7 @@ import httpResolver from "./resolvers/http.js";
 
 import type { HTTPResolverOptions, JSONSchemaObject, Plugin, ResolverOptions } from "./types/index.js";
 
-type DeepPartial<T> = T extends object
+export type DeepPartial<T> = T extends object
   ? {
       [P in keyof T]?: DeepPartial<T[P]>;
     }
@@ -18,7 +18,7 @@ type DeepPartial<T> = T extends object
  * @param [options] - Overridden options
  * @class
  */
-interface $RefParserOptions {
+export interface $RefParserOptions {
   /**
    * The `parse` options determine how different types of files will be parsed.
    *
@@ -101,7 +101,7 @@ interface $RefParserOptions {
   };
 }
 
-const getDefaults = () => {
+export const getJsonSchemaRefParserDefaultOptions = () => {
   const defaults = {
     /**
      * Determines how different types of files will be parsed.
@@ -172,8 +172,8 @@ const getDefaults = () => {
   return defaults;
 };
 
-export const getNewOptions = (options: DeepPartial<$RefParserOptions>): $RefParserOptions => {
-  const newOptions = getDefaults();
+export const getNewOptions = (options: DeepPartial<$RefParserOptions> | undefined): $RefParserOptions => {
+  const newOptions = getJsonSchemaRefParserDefaultOptions();
   if (options) {
     merge(newOptions, options);
   }

package/lib/types/index.ts

@@ -10,7 +10,7 @@ import type $Refs from "../refs.js";
 
 export type JSONSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
 export type JSONSchemaObject = JSONSchema4Object | JSONSchema6Object | JSONSchema7Object;
-export type SchemaCallback = (err: Error | null, schema?: JSONSchema | object) => any;
+export type SchemaCallback = (err: Error | null, schema?: JSONSchema | object | null) => any;
 export type $RefsCallback = (err: Error | null, $refs?: $Refs) => any;
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apidevtools/json-schema-ref-parser",
-  "version": "11.4.0",
+  "version": "11.4.2",
   "description": "Parse, Resolve, and Dereference JSON Schema $ref pointers",
   "keywords": [
     "json",