vira 32.0.0-beta.0 → 32.0.0

package/{src/util/vira-json-schema.ts → dist/util/vira-json-schema.js}

@@ -1,44 +1,26 @@
-import {assertWrap, check} from '@augment-vir/assert';
-import {omitObjectKeys, removeDuplicates, removePrefix, type JsonValue} from '@augment-vir/common';
-import {type JSONSchema} from 'json-schema-to-ts';
-
-/**
- * The JSON Schema type used by `ViraJsonForm`. Re-exported from `json-schema-to-ts` so that callers
- * can pass standard JSON Schema objects.
- *
- * @category Internal
- */
-export type ViraJsonSchema = JSONSchema;
-
-/**
- * A non-boolean JSON Schema object. Boolean schemas (`true` / `false`) are valid JSON Schemas but
- * don't constrain the editor in useful ways, so we normalize them away during traversal.
- *
- * @category Internal
- */
-export type ViraJsonSchemaObject = Exclude<ViraJsonSchema, boolean>;
-
+import { assertWrap, check } from '@augment-vir/assert';
+import { omitObjectKeys, removeDuplicates, removePrefix } from '@augment-vir/common';
 /**
  * The JSON types supported by `ViraJsonForm`.
  *
  * @category Internal
  */
-export enum ViraJsonType {
-    String = 'string',
-    Number = 'number',
-    Integer = 'integer',
-    Boolean = 'boolean',
-    Null = 'null',
-    Object = 'object',
-    Array = 'array',
-}
-
+export var ViraJsonType;
+(function (ViraJsonType) {
+    ViraJsonType["String"] = "string";
+    ViraJsonType["Number"] = "number";
+    ViraJsonType["Integer"] = "integer";
+    ViraJsonType["Boolean"] = "boolean";
+    ViraJsonType["Null"] = "null";
+    ViraJsonType["Object"] = "object";
+    ViraJsonType["Array"] = "array";
+})(ViraJsonType || (ViraJsonType = {}));
 /**
  * Human-friendly labels for each {@link ViraJsonType}.
  *
  * @category Internal
  */
-export const viraJsonTypeLabels: Readonly<Record<ViraJsonType, string>> = {
+export const viraJsonTypeLabels = {
     [ViraJsonType.String]: 'string',
     [ViraJsonType.Number]: 'number',
     [ViraJsonType.Integer]: 'integer',
@@ -47,8 +29,7 @@ export const viraJsonTypeLabels: Readonly<Record<ViraJsonType, string>> = {
     [ViraJsonType.Object]: 'object',
     [ViraJsonType.Array]: 'array',
 };
-
-const allJsonTypes: ReadonlyArray<ViraJsonType> = [
+const allJsonTypes = [
     ViraJsonType.String,
     ViraJsonType.Number,
     ViraJsonType.Integer,
@@ -57,7 +38,6 @@ const allJsonTypes: ReadonlyArray<ViraJsonType> = [
     ViraJsonType.Object,
     ViraJsonType.Array,
 ];
-
 /**
  * Classifies a JSON value's runtime type. Note that {@link ViraJsonType.Integer} is never returned;
  * it only appears in schemas. All numbers (whole or fractional) classify as
@@ -65,101 +45,83 @@ const allJsonTypes: ReadonlyArray<ViraJsonType> = [
  *
  * @category Internal
  */
-export function getJsonType(value: JsonValue | undefined): ViraJsonType {
+export function getJsonType(value) {
     if (value === null) {
         return ViraJsonType.Null;
-    } else if (check.isArray(value)) {
+    }
+    else if (check.isArray(value)) {
         return ViraJsonType.Array;
-    } else if (check.isObject(value)) {
+    }
+    else if (check.isObject(value)) {
         return ViraJsonType.Object;
-    } else if (check.isBoolean(value)) {
+    }
+    else if (check.isBoolean(value)) {
         return ViraJsonType.Boolean;
-    } else if (check.isNumber(value)) {
+    }
+    else if (check.isNumber(value)) {
         return ViraJsonType.Number;
-    } else {
+    }
+    else {
         return ViraJsonType.String;
     }
 }
-
 /**
  * Normalizes a schema to a non-boolean object form. `true` becomes an unconstrained schema (`{}`),
  * `false` becomes `undefined` (nothing is allowed; treated as "no schema available").
  *
  * @category Internal
  */
-export function normalizeSchema(
-    schema: ViraJsonSchema | undefined,
-): ViraJsonSchemaObject | undefined {
-    if (schema === undefined || schema === false) {
+export function normalizeSchema(schema) {
+    if (schema == undefined || schema === false) {
         return undefined;
-    } else if (schema === true) {
+    }
+    else if (schema === true) {
         return {};
-    } else {
+    }
+    else {
         return schema;
     }
 }
-
-function jsonTypeFromSchemaType(type: string): ViraJsonType | undefined {
-    if (allJsonTypes.includes(type as ViraJsonType)) {
-        return type as ViraJsonType;
+function jsonTypeFromSchemaType(type) {
+    if (allJsonTypes.includes(type)) {
+        return type;
     }
     return undefined;
 }
-
-/**
- * Context used while resolving `$ref` entries against a root schema's `$defs` (or `definitions`)
- * map. A stack of seen refs prevents infinite recursion from cyclical schemas.
- *
- * @category Internal
- */
-export type SchemaResolveContext = {
-    root: ViraJsonSchemaObject | undefined;
-    seenRefs: ReadonlySet<string>;
-};
-
 /** @category Internal */
-export function createResolveContext(schema: ViraJsonSchema | undefined): SchemaResolveContext {
+export function createResolveContext(schema) {
     return {
         root: normalizeSchema(schema),
         seenRefs: new Set(),
     };
 }
-
-function resolveRef(
-    ref: string,
-    context: SchemaResolveContext,
-): {resolved: ViraJsonSchemaObject | undefined; context: SchemaResolveContext} {
+function resolveRef(ref, context) {
     if (context.seenRefs.has(ref) || !context.root) {
         return {
             resolved: undefined,
             context,
         };
     }
-
     const defsKey = ref.startsWith('#/$defs/')
         ? removePrefix({
-              value: ref,
-              prefix: '#/$defs/',
-          })
+            value: ref,
+            prefix: '#/$defs/',
+        })
         : ref.startsWith('#/definitions/')
-          ? removePrefix({
+            ? removePrefix({
                 value: ref,
                 prefix: '#/definitions/',
             })
-          : undefined;
-
+            : undefined;
     if (!defsKey) {
         return {
             resolved: undefined,
             context,
         };
     }
-
-    const defsRecord =
-        (context.root as {$defs?: Record<string, ViraJsonSchema>}).$defs ??
-        (context.root as {definitions?: Record<string, ViraJsonSchema>}).definitions;
+    const defsRecord = context.root.$defs ??
+        context.root.definitions;
     const resolved = normalizeSchema(defsRecord?.[defsKey]);
-
     return {
         resolved,
         context: {
@@ -171,17 +133,13 @@ function resolveRef(
         },
     };
 }
-
 /**
  * Resolves a schema through `$ref` (via its root's `$defs`/`definitions`), returning the resolved
  * schema and an updated resolve context. Non-ref schemas are returned as-is.
  *
  * @category Internal
  */
-export function resolveSchema(
-    schema: ViraJsonSchema | undefined,
-    context: SchemaResolveContext,
-): {resolved: ViraJsonSchemaObject | undefined; context: SchemaResolveContext} {
+export function resolveSchema(schema, context) {
     const normalized = normalizeSchema(schema);
     if (!normalized) {
         return {
@@ -189,7 +147,7 @@ export function resolveSchema(
             context,
         };
     }
-    const ref = (normalized as {$ref?: string}).$ref;
+    const ref = normalized.$ref;
     if (check.isString(ref)) {
         return resolveRef(ref, context);
     }
@@ -198,24 +156,20 @@ export function resolveSchema(
         context,
     };
 }
-
 /**
  * Flattens `anyOf` / `oneOf` branches into a single list of non-union schemas so that the editor
  * can treat them uniformly.
  *
  * @category Internal
  */
-export function expandSchemaBranches(
-    schema: ViraJsonSchema | undefined,
-    context: SchemaResolveContext,
-): ReadonlyArray<ViraJsonSchemaObject> {
-    const {resolved} = resolveSchema(schema, context);
+export function expandSchemaBranches(schema, context) {
+    const { resolved } = resolveSchema(schema, context);
     if (!resolved) {
         return [];
     }
     const branches = [
-        ...((resolved as {anyOf?: ReadonlyArray<ViraJsonSchema>}).anyOf ?? []),
-        ...((resolved as {oneOf?: ReadonlyArray<ViraJsonSchema>}).oneOf ?? []),
+        ...(resolved.anyOf ?? []),
+        ...(resolved.oneOf ?? []),
     ];
     if (branches.length === 0) {
         return [resolved];
@@ -227,41 +181,39 @@ export function expandSchemaBranches(
         });
     });
 }
-
 /**
  * Computes the set of JSON types that a given schema allows.
  *
  * @category Internal
  */
-export function getAllowedJsonTypes(
-    schema: ViraJsonSchema | undefined,
-    context: SchemaResolveContext,
-): ReadonlyArray<ViraJsonType> {
+export function getAllowedJsonTypes(schema, context) {
     const branches = expandSchemaBranches(schema, context);
     if (branches.length === 0) {
         return allJsonTypes;
     }
-    const collected: ViraJsonType[] = [];
+    const collected = [];
     for (const branch of branches) {
         const schemaType = branch.type;
         if (schemaType == undefined) {
             if ('const' in branch || 'enum' in branch) {
-                const source =
-                    'enum' in branch && check.isArray(branch.enum) ? branch.enum : [branch.const];
+                const source = 'enum' in branch && check.isArray(branch.enum) ? branch.enum : [branch.const];
                 for (const entry of source) {
-                    collected.push(getJsonType(entry as JsonValue | undefined));
+                    collected.push(getJsonType(entry));
                 }
-            } else {
+            }
+            else {
                 return allJsonTypes;
             }
-        } else if (check.isArray(schemaType)) {
+        }
+        else if (check.isArray(schemaType)) {
             for (const entry of schemaType) {
                 const mapped = jsonTypeFromSchemaType(entry);
                 if (mapped) {
                     collected.push(mapped);
                 }
             }
-        } else {
+        }
+        else {
             const mapped = jsonTypeFromSchemaType(schemaType);
             if (mapped) {
                 collected.push(mapped);
@@ -270,10 +222,9 @@ export function getAllowedJsonTypes(
     }
     return removeDuplicates(collected);
 }
-
 /** @category Internal */
-export function createDefaultForJsonType(type: ViraJsonType): JsonValue {
-    const defaults: Readonly<Record<ViraJsonType, JsonValue>> = {
+export function createDefaultForJsonType(type) {
+    const defaults = {
         [ViraJsonType.String]: '',
         [ViraJsonType.Number]: 0,
         [ViraJsonType.Integer]: 0,
@@ -284,18 +235,13 @@ export function createDefaultForJsonType(type: ViraJsonType): JsonValue {
     };
     return defaults[type];
 }
-
 /**
  * Picks the first schema branch whose `type` contains (or is) the given JSON type. Used to narrow
  * the schema when traversing into a concrete value.
  *
  * @category Internal
  */
-export function pickBranchForType(
-    schema: ViraJsonSchema | undefined,
-    valueType: ViraJsonType,
-    context: SchemaResolveContext,
-): ViraJsonSchemaObject | undefined {
+export function pickBranchForType(schema, valueType, context) {
     const branches = expandSchemaBranches(schema, context);
     for (const branch of branches) {
         const branchTypes = getAllowedJsonTypes(branch, context);
@@ -303,12 +249,11 @@ export function pickBranchForType(
             return branch;
         }
     }
-    const numericFallback =
-        valueType === ViraJsonType.Number
-            ? ViraJsonType.Integer
-            : valueType === ViraJsonType.Integer
-              ? ViraJsonType.Number
-              : undefined;
+    const numericFallback = valueType === ViraJsonType.Number
+        ? ViraJsonType.Integer
+        : valueType === ViraJsonType.Integer
+            ? ViraJsonType.Number
+            : undefined;
     if (numericFallback) {
         for (const branch of branches) {
             const branchTypes = getAllowedJsonTypes(branch, context);
@@ -319,55 +264,43 @@ export function pickBranchForType(
     }
     return branches[0];
 }
-
 /**
  * Finds the sub-schema for a given object property key, considering `properties`,
  * `patternProperties`, and `additionalProperties`.
  *
  * @category Internal
  */
-export function getPropertySchema(
-    parentSchema: ViraJsonSchema | undefined,
-    key: string,
-    context: SchemaResolveContext,
-): ViraJsonSchema | undefined {
+export function getPropertySchema(parentSchema, key, context) {
     const branch = pickBranchForType(parentSchema, ViraJsonType.Object, context);
     if (!branch) {
         return undefined;
     }
     const propertySchema = branch.properties?.[key];
-    if (propertySchema !== undefined) {
+    if (propertySchema != undefined) {
         return propertySchema;
     }
     const patternProperties = branch.patternProperties;
     if (patternProperties) {
-        for (const [
-            pattern,
-            subSchema,
-        ] of Object.entries(patternProperties)) {
+        for (const [pattern, subSchema,] of Object.entries(patternProperties)) {
             try {
                 if (new RegExp(pattern).test(key)) {
                     return subSchema;
                 }
-            } catch {
+            }
+            catch {
                 continue;
             }
         }
     }
     return branch.additionalProperties;
 }
-
 /**
  * Finds the sub-schema for an array item at a given index, considering tuple `items` arrays and
  * `additionalItems` fallbacks.
  *
  * @category Internal
  */
-export function getItemSchema(
-    parentSchema: ViraJsonSchema | undefined,
-    index: number,
-    context: SchemaResolveContext,
-): ViraJsonSchema | undefined {
+export function getItemSchema(parentSchema, index, context) {
     const branch = pickBranchForType(parentSchema, ViraJsonType.Array, context);
     if (!branch) {
         return undefined;
@@ -378,21 +311,15 @@ export function getItemSchema(
     }
     return items;
 }
-
 /**
  * Returns the schema used when appending a new item to an array. Falls back to `additionalItems`
  * when `items` is a tuple array and the new index is beyond the tuple's length.
  *
  * @category Internal
  */
-export function getNewItemSchema(
-    parentSchema: ViraJsonSchema | undefined,
-    currentLength: number,
-    context: SchemaResolveContext,
-): ViraJsonSchema | undefined {
+export function getNewItemSchema(parentSchema, currentLength, context) {
     return getItemSchema(parentSchema, currentLength, context);
 }
-
 /**
  * Returns the schema used when adding an arbitrary new field to an object. When no schema is
  * provided at all the editor is unconstrained, so additions are allowed; once a schema is provided,
@@ -402,11 +329,8 @@ export function getNewItemSchema(
  *
  * @category Internal
  */
-export function getAdditionalPropertiesSchema(
-    parentSchema: ViraJsonSchema | undefined,
-    context: SchemaResolveContext,
-): {allowed: boolean; schema: ViraJsonSchema | undefined} {
-    if (parentSchema === undefined) {
+export function getAdditionalPropertiesSchema(parentSchema, context) {
+    if (parentSchema == undefined) {
         return {
             allowed: true,
             schema: undefined,
@@ -420,7 +344,7 @@ export function getAdditionalPropertiesSchema(
         };
     }
     const additional = branch.additionalProperties;
-    if (additional === undefined || additional === false) {
+    if (additional == undefined || additional === false) {
         return {
             allowed: false,
             schema: undefined,
@@ -431,36 +355,33 @@ export function getAdditionalPropertiesSchema(
         schema: additional === true ? undefined : additional,
     };
 }
-
 /**
  * Returns the `enum` values defined by any resolved branch of a schema. Aggregates across
  * `anyOf`/`oneOf` branches and includes `const` values so the editor can offer them as a select.
  *
  * @category Internal
  */
-export function getSchemaEnumValues(
-    schema: ViraJsonSchema | undefined,
-    context: SchemaResolveContext,
-): ReadonlyArray<JsonValue> | undefined {
+export function getSchemaEnumValues(schema, context) {
     const branches = expandSchemaBranches(schema, context);
     if (branches.length === 0) {
         return undefined;
     }
-    const collected: JsonValue[] = [];
+    const collected = [];
     for (const branch of branches) {
         if ('enum' in branch && check.isArray(branch.enum)) {
             for (const entry of branch.enum) {
-                collected.push(entry as JsonValue);
+                collected.push(entry);
             }
-        } else if ('const' in branch) {
-            collected.push(branch.const as JsonValue);
-        } else {
+        }
+        else if ('const' in branch) {
+            collected.push(branch.const);
+        }
+        else {
             return undefined;
         }
     }
     return collected.length > 0 ? collected : undefined;
 }
-
 /**
  * Collects the string `enum`/`const` values declared by any branch of a schema, ignoring branches
  * that declare no enum/const. Unlike {@link getSchemaEnumValues}, a schema that mixes an enum branch
@@ -469,23 +390,21 @@ export function getSchemaEnumValues(
  *
  * @category Internal
  */
-export function getStringEnumValues(
-    schema: ViraJsonSchema | undefined,
-    context: SchemaResolveContext,
-): ReadonlyArray<string> {
+export function getStringEnumValues(schema, context) {
     const branches = expandSchemaBranches(schema, context);
-    const values = branches.flatMap((branch): ReadonlyArray<string> => {
+    const values = branches.flatMap((branch) => {
         if ('enum' in branch && check.isArray(branch.enum)) {
             return branch.enum.filter(check.isString);
-        } else if ('const' in branch && check.isString(branch.const)) {
+        }
+        else if ('const' in branch && check.isString(branch.const)) {
             return [branch.const];
-        } else {
+        }
+        else {
             return [];
         }
     });
     return removeDuplicates(values);
 }
-
 /**
  * Returns whether the schema permits an arbitrary (non-enum, non-const) string in any of its
  * branches. Used alongside {@link getStringEnumValues} to detect fields that accept both a fixed set
@@ -493,10 +412,7 @@ export function getStringEnumValues(
  *
  * @category Internal
  */
-export function allowsFreeformString(
-    schema: ViraJsonSchema | undefined,
-    context: SchemaResolveContext,
-): boolean {
+export function allowsFreeformString(schema, context) {
     return expandSchemaBranches(schema, context).some((branch) => {
         if ('enum' in branch || 'const' in branch) {
             return false;
@@ -504,43 +420,31 @@ export function allowsFreeformString(
         return getAllowedJsonTypes(branch, context).includes(ViraJsonType.String);
     });
 }
-
 /**
  * Returns the list of required property names declared by the object branch of a schema.
  *
  * @category Internal
  */
-export function getRequiredProperties(
-    schema: ViraJsonSchema | undefined,
-    context: SchemaResolveContext,
-): ReadonlyArray<string> {
+export function getRequiredProperties(schema, context) {
     const branch = pickBranchForType(schema, ViraJsonType.Object, context);
     return branch?.required ?? [];
 }
-
 /**
  * Returns the `properties` map declared by the object branch of a schema, or an empty record when
  * none is defined.
  *
  * @category Internal
  */
-export function getDefinedProperties(
-    schema: ViraJsonSchema | undefined,
-    context: SchemaResolveContext,
-): Readonly<Record<string, ViraJsonSchema>> {
+export function getDefinedProperties(schema, context) {
     const branch = pickBranchForType(schema, ViraJsonType.Object, context);
     return branch?.properties ?? {};
 }
-
 /**
  * Reads the title of a schema's first resolved branch (for display purposes).
  *
  * @category Internal
  */
-export function getSchemaTitle(
-    schema: ViraJsonSchema | undefined,
-    context: SchemaResolveContext,
-): string | undefined {
+export function getSchemaTitle(schema, context) {
     const branches = expandSchemaBranches(schema, context);
     for (const branch of branches) {
         if (check.isString(branch.title)) {
@@ -549,8 +453,7 @@ export function getSchemaTitle(
     }
     return undefined;
 }
-
-function formatPathLabel(path: ViraJsonPath): string {
+function formatPathLabel(path) {
     if (path.length === 0) {
         return 'root';
     }
@@ -559,14 +462,12 @@ function formatPathLabel(path: ViraJsonPath): string {
         .join('')
         .replace(/^\./, '');
 }
-
-function isJsonValueMatchingType(value: JsonValue, type: ViraJsonType): boolean {
+function isJsonValueMatchingType(value, type) {
     if (type === ViraJsonType.Integer) {
         return check.isNumber(value) && Number.isInteger(value);
     }
     return getJsonType(value) === type;
 }
-
 /**
  * Validates a JSON value against the (loose) JSON Schema subset supported by `ViraJsonForm`.
  * Returns a list of human-readable error messages; an empty array means the value is valid. Only
@@ -575,15 +476,12 @@ function isJsonValueMatchingType(value: JsonValue, type: ViraJsonType): boolean
  *
  * @category Internal
  */
-export function validateAgainstSchema(
-    value: JsonValue,
-    schema: ViraJsonSchema | undefined,
-): ReadonlyArray<string> {
-    if (schema === undefined) {
+export function validateAgainstSchema(value, schema) {
+    if (schema == undefined) {
         return [];
     }
     const context = createResolveContext(schema);
-    const errors: string[] = [];
+    const errors = [];
     validateRecursive({
         value,
         schema,
@@ -593,27 +491,14 @@ export function validateAgainstSchema(
     });
     return errors;
 }
-
-function validateRecursive({
-    value,
-    schema,
-    path,
-    context,
-    errors,
-}: Readonly<{
-    value: JsonValue;
-    schema: ViraJsonSchema | undefined;
-    path: ViraJsonPath;
-    context: SchemaResolveContext;
-    errors: string[];
-}>): void {
+function validateRecursive({ value, schema, path, context, errors, }) {
     const branches = expandSchemaBranches(schema, context);
     if (branches.length === 0) {
         return;
     }
-    const branchErrorSets: string[][] = [];
+    const branchErrorSets = [];
     for (const branch of branches) {
-        const branchErrors: string[] = [];
+        const branchErrors = [];
         validateBranch({
             value,
             branch,
@@ -628,49 +513,29 @@ function validateRecursive({
     }
     if (branches.length === 1) {
         errors.push(...assertWrap.isDefined(branchErrorSets[0]));
-    } else {
-        errors.push(
-            `${formatPathLabel(path)} did not match any allowed schema branch (anyOf/oneOf).`,
-        );
+    }
+    else {
+        errors.push(`${formatPathLabel(path)} did not match any allowed schema branch (anyOf/oneOf).`);
     }
 }
-
-function validateBranch({
-    value,
-    branch,
-    path,
-    context,
-    errors,
-}: Readonly<{
-    value: JsonValue;
-    branch: ViraJsonSchemaObject;
-    path: ViraJsonPath;
-    context: SchemaResolveContext;
-    errors: string[];
-}>): void {
+function validateBranch({ value, branch, path, context, errors, }) {
     const allowedTypes = getAllowedJsonTypes(branch, context);
     const concreteType = getJsonType(value);
     if (allowedTypes.length > 0) {
         const matchesAny = allowedTypes.some((type) => isJsonValueMatchingType(value, type));
         if (!matchesAny) {
             const allowedLabel = allowedTypes.map((type) => viraJsonTypeLabels[type]).join(' | ');
-            errors.push(
-                `${formatPathLabel(path)} expected ${allowedLabel} but got ${
-                    concreteType === ViraJsonType.Number && Number.isInteger(value)
-                        ? 'integer'
-                        : viraJsonTypeLabels[concreteType]
-                }.`,
-            );
+            errors.push(`${formatPathLabel(path)} expected ${allowedLabel} but got ${concreteType === ViraJsonType.Number && Number.isInteger(value)
+                ? 'integer'
+                : viraJsonTypeLabels[concreteType]}.`);
             return;
         }
     }
-    if (
-        'const' in branch &&
+    if ('const' in branch &&
         !deepEqualsJson({
             a: value,
-            b: branch.const as JsonValue,
-        })
-    ) {
+            b: branch.const,
+        })) {
         errors.push(`${formatPathLabel(path)} must equal const value.`);
         return;
     }
@@ -678,7 +543,7 @@ function validateBranch({
         const matched = branch.enum.some((entry) => {
             return deepEqualsJson({
                 a: value,
-                b: entry as JsonValue,
+                b: entry,
             });
         });
         if (!matched) {
@@ -695,16 +560,13 @@ function validateBranch({
         }
         const additional = branch.additionalProperties;
         const definedKeys = new Set(Object.keys(branch.properties ?? {}));
-        for (const [
-            propKey,
-            propValue,
-        ] of Object.entries(value)) {
-            const propPath: ViraJsonPath = [
+        for (const [propKey, propValue,] of Object.entries(value)) {
+            const propPath = [
                 ...path,
                 propKey,
             ];
             const propSchema = branch.properties?.[propKey];
-            if (propSchema !== undefined) {
+            if (propSchema != undefined) {
                 validateRecursive({
                     value: propValue,
                     schema: propSchema,
@@ -712,11 +574,11 @@ function validateBranch({
                     context,
                     errors,
                 });
-            } else if (additional === false) {
-                errors.push(
-                    `${formatPathLabel(propPath)} is not allowed (additionalProperties is false).`,
-                );
-            } else if (check.isObject(additional)) {
+            }
+            else if (additional === false) {
+                errors.push(`${formatPathLabel(propPath)} is not allowed (additionalProperties is false).`);
+            }
+            else if (check.isObject(additional)) {
                 validateRecursive({
                     value: propValue,
                     schema: additional,
@@ -724,20 +586,22 @@ function validateBranch({
                     context,
                     errors,
                 });
-            } else if (additional === undefined && definedKeys.size > 0) {
+            }
+            else if (additional == undefined && definedKeys.size > 0) {
                 continue;
             }
         }
-    } else if (check.isArray(value)) {
+    }
+    else if (check.isArray(value)) {
         const items = branch.items;
         value.forEach((item, index) => {
-            const itemPath: ViraJsonPath = [
+            const itemPath = [
                 ...path,
                 index,
             ];
             if (check.isArray(items)) {
                 const tupleSchema = items[index] ?? branch.additionalItems;
-                if (tupleSchema !== undefined) {
+                if (tupleSchema != undefined) {
                     validateRecursive({
                         value: item,
                         schema: tupleSchema,
@@ -746,7 +610,8 @@ function validateBranch({
                         errors,
                     });
                 }
-            } else if (items !== undefined) {
+            }
+            else if (items != undefined) {
                 validateRecursive({
                     value: item,
                     schema: items,
@@ -758,21 +623,20 @@ function validateBranch({
         });
     }
 }
-
-function deepEqualsJson({a, b}: Readonly<{a: JsonValue; b: JsonValue}>): boolean {
+function deepEqualsJson({ a, b }) {
     if (a === b) {
         return true;
-    } else if (check.isArray(a) && check.isArray(b)) {
-        return (
-            a.length === b.length &&
+    }
+    else if (check.isArray(a) && check.isArray(b)) {
+        return (a.length === b.length &&
             a.every((entry, i) => {
                 return deepEqualsJson({
                     a: entry,
                     b: b[i] ?? null,
                 });
-            })
-        );
-    } else if (check.isObject(a) && check.isObject(b)) {
+            }));
+    }
+    else if (check.isObject(a) && check.isObject(b)) {
         const aKeys = Object.keys(a);
         const bKeys = Object.keys(b);
         if (aKeys.length !== bKeys.length) {
@@ -784,33 +648,21 @@ function deepEqualsJson({a, b}: Readonly<{a: JsonValue; b: JsonValue}>): boolean
                 b: b[key] ?? null,
             });
         });
-    } else {
+    }
+    else {
         return false;
     }
 }
-
-/**
- * Type of a JSON path element. `string` selects an object key; `number` selects an array index.
- *
- * @category Internal
- */
-export type ViraJsonPath = ReadonlyArray<string | number>;
-
 /** @category Internal */
-export function pathToKey(path: ViraJsonPath): string {
+export function pathToKey(path) {
     return JSON.stringify(path);
 }
-
 /**
  * Returns a new JSON value where the value at `path` has been replaced with `newValue`.
  *
  * @category Internal
  */
-export function setValueAtPath({
-    root,
-    path,
-    newValue,
-}: Readonly<{root: JsonValue; path: ViraJsonPath; newValue: JsonValue}>): JsonValue {
+export function setValueAtPath({ root, path, newValue, }) {
     if (path.length === 0) {
         return newValue;
     }
@@ -825,7 +677,7 @@ export function setValueAtPath({
             newValue,
         });
         if (head >= array.length) {
-            const extended: JsonValue[] = [...array];
+            const extended = [...array];
             while (extended.length < head) {
                 extended.push(null);
             }
@@ -833,7 +685,8 @@ export function setValueAtPath({
             return extended;
         }
         return array.map((item, index) => (index === head ? replaced : item));
-    } else {
+    }
+    else {
         const object = check.isObject(root) ? root : {};
         const existing = object[head] ?? null;
         return {
@@ -846,14 +699,13 @@ export function setValueAtPath({
         };
     }
 }
-
 /**
  * Returns a new JSON value where the value at `path` has been removed. If `path` targets an object
  * key, the key is deleted; if it targets an array index, the item is spliced out.
  *
  * @category Internal
  */
-export function deleteValueAtPath(root: JsonValue, path: ViraJsonPath): JsonValue {
+export function deleteValueAtPath(root, path) {
     if (path.length === 0) {
         return root;
     }
@@ -862,19 +714,24 @@ export function deleteValueAtPath(root: JsonValue, path: ViraJsonPath): JsonValu
     if (rest.length === 0) {
         if (typeof head === 'number' && check.isArray(root)) {
             return root.filter((unusedItem, index) => index !== head);
-        } else if (typeof head === 'string' && check.isObject(root)) {
+        }
+        else if (typeof head === 'string' && check.isObject(root)) {
             return omitObjectKeys(root, [head]);
-        } else {
+        }
+        else {
             return root;
         }
-    } else if (typeof head === 'number' && check.isArray(root)) {
+    }
+    else if (typeof head === 'number' && check.isArray(root)) {
         return root.map((item, index) => (index === head ? deleteValueAtPath(item, rest) : item));
-    } else if (typeof head === 'string' && check.isObject(root)) {
+    }
+    else if (typeof head === 'string' && check.isObject(root)) {
         return {
             ...root,
             [head]: deleteValueAtPath(root[head] ?? null, rest),
         };
-    } else {
+    }
+    else {
         return root;
     }
 }