typebox 1.1.36 → 1.1.37

package/build/guard/guard.d.mts

@@ -49,6 +49,8 @@ export declare function Every<T>(value: T[], offset: number, callback: (value: T
 export declare function EveryAll<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
 /** Takes the left-most element from an array and dispatches to the true arm, or the false arm if empty */
 export declare function TakeLeft<T, True extends (left: T, right: T[]) => unknown, False extends () => unknown>(array: T[], true_: True, false_: False): ReturnType<True> | ReturnType<False>;
+/** Returns true if the PropertyKey is Unsafe (ref: prototype-pollution). */
+export declare function IsUnsafePropertyKey(key: PropertyKey): boolean;
 /** Returns true if this value has this property key */
 export declare function HasPropertyKey<Key extends PropertyKey>(value: object, key: Key): value is {
     [_ in Key]: unknown;
@@ -57,7 +59,7 @@ export declare function HasPropertyKey<Key extends PropertyKey>(value: object, k
 export declare function EntriesRegExp<Value extends unknown = unknown>(value: Record<PropertyKey, Value>): [RegExp, Value][];
 /** Returns object entries as `[string, Value][]` */
 export declare function Entries<Value extends unknown = unknown>(value: Record<PropertyKey, Value>): [string, Value][];
-/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+/** Returns property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
 export declare function Keys(value: Record<PropertyKey, unknown>): string[];
 /** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
 export declare function Symbols(value: Record<PropertyKey, unknown>): symbol[];

package/build/guard/guard.mjs

@@ -169,10 +169,13 @@ export function TakeLeft(array, true_, false_) {
 // --------------------------------------------------------------------------
 // Object
 // --------------------------------------------------------------------------
+/** Returns true if the PropertyKey is Unsafe (ref: prototype-pollution). */
+export function IsUnsafePropertyKey(key) {
+    return IsEqual(key, '__proto__') || IsEqual(key, 'constructor') || IsEqual(key, 'prototype');
+}
 /** Returns true if this value has this property key */
 export function HasPropertyKey(value, key) {
-    const isProtoField = IsEqual(key, '__proto__') || IsEqual(key, 'constructor');
-    return isProtoField ? Object.prototype.hasOwnProperty.call(value, key) : key in value;
+    return IsUnsafePropertyKey(key) ? Object.prototype.hasOwnProperty.call(value, key) : key in value;
 }
 /** Returns object entries as `[RegExp, Value][]` */
 export function EntriesRegExp(value) {
@@ -182,7 +185,7 @@ export function EntriesRegExp(value) {
 export function Entries(value) {
     return Object.entries(value);
 }
-/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+/** Returns property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
 export function Keys(value) {
     return Object.getOwnPropertyNames(value);
 }

package/build/schema/pointer/pointer.mjs

@@ -11,6 +11,14 @@ function AssertCanSet(value) {
     if (!Guard.IsObject(value))
         throw Error('Cannot set value');
 }
+function AssertIndex(index) {
+    if (Guard.IsUnsafePropertyKey(index))
+        throw Error('Pointer contains unsafe property key');
+}
+function AssertIndices(indices) {
+    for (const index of indices)
+        AssertIndex(index);
+}
 // ------------------------------------------------------------------
 // Indices
 // ------------------------------------------------------------------
@@ -27,7 +35,7 @@ function HasIndex(index, value) {
     return Guard.IsObject(value) && Guard.HasPropertyKey(value, index);
 }
 function GetIndex(index, value) {
-    return Guard.IsObject(value) ? value[index] : undefined;
+    return Guard.IsObject(value) && !Guard.IsUnsafePropertyKey(index) ? value[index] : undefined;
 }
 function GetIndices(indices, value) {
     return indices.reduce((value, index) => GetIndex(index, value), value);
@@ -70,6 +78,7 @@ export function Get(value, pointer) {
 export function Set(value, pointer, next) {
     const indices = Indices(pointer);
     AssertNotRoot(indices);
+    AssertIndices(indices);
     const [head, index] = TakeIndexRight(indices);
     const parent = GetIndices(head, value);
     AssertCanSet(parent);
@@ -83,6 +92,7 @@ export function Set(value, pointer, next) {
 export function Delete(value, pointer) {
     const indices = Indices(pointer);
     AssertNotRoot(indices);
+    AssertIndices(indices);
     const [head, index] = TakeIndexRight(indices);
     const parent = GetIndices(head, value);
     AssertCanSet(parent);

package/build/value/clone/clone.mjs

@@ -18,15 +18,16 @@ function FromClassInstance(value) {
 // ------------------------------------------------------------------
 function FromObjectInstance(value) {
     const result = {};
-    for (const key of Object.getOwnPropertyNames(value)) {
+    for (const key of Guard.Keys(value)) {
+        if (Guard.IsUnsafePropertyKey(key))
+            continue; // (ignore: prototype-pollution)
         result[key] = Clone(value[key]);
     }
-    for (const key of Object.getOwnPropertySymbols(value)) {
+    for (const key of Guard.Symbols(value)) {
         result[key] = Clone(value[key]);
     }
     return result;
 }
-Object.create({});
 // ------------------------------------------------------------------
 // Object
 // ------------------------------------------------------------------

package/build/value/delta/diff.mjs

@@ -37,6 +37,8 @@ function* FromObject(path, left, right) {
     for (const key of rightKeys) {
         if (Guard.HasPropertyKey(left, key))
             continue;
+        if (Guard.IsUnsafePropertyKey(key))
+            continue;
         yield CreateInsert(`${path}/${key}`, right[key]);
     }
     // ----------------------------------------------------------------
@@ -45,6 +47,8 @@ function* FromObject(path, left, right) {
     for (const key of leftKeys) {
         if (!Guard.HasPropertyKey(right, key))
             continue;
+        if (Guard.IsUnsafePropertyKey(key))
+            continue;
         if (Equal(left, right))
             continue;
         yield* FromValue(`${path}/${key}`, left[key], right[key]);
@@ -55,6 +59,8 @@ function* FromObject(path, left, right) {
     for (const key of leftKeys) {
         if (Guard.HasPropertyKey(right, key))
             continue;
+        if (Guard.IsUnsafePropertyKey(key))
+            continue;
         yield CreateDelete(`${path}/${key}`);
     }
 }

package/build/value/mutate/from_object.mjs

@@ -3,6 +3,16 @@ import { Guard } from '../../guard/index.mjs';
 import { Pointer } from '../pointer/index.mjs';
 import { Clone } from '../clone/index.mjs';
 import { FromValue } from './from_value.mjs';
+// ------------------------------------------------------------------
+// AssertKey
+// ------------------------------------------------------------------
+function AssertKey(key) {
+    if (Guard.IsUnsafePropertyKey(key))
+        throw Error('Attempted to Mutate with unsafe property key');
+}
+// ------------------------------------------------------------------
+// AssertKey
+// ------------------------------------------------------------------
 export function FromObject(root, path, current, next) {
     if (!Guard.IsObjectNotArray(current)) {
         Pointer.Set(root, path, Clone(next));
@@ -11,16 +21,19 @@ export function FromObject(root, path, current, next) {
         const currentKeys = Guard.Keys(current);
         const nextKeys = Guard.Keys(next);
         for (const currentKey of currentKeys) {
+            AssertKey(currentKey);
             if (!nextKeys.includes(currentKey)) {
                 delete current[currentKey];
             }
         }
         for (const nextKey of nextKeys) {
+            AssertKey(nextKey);
             if (!currentKeys.includes(nextKey)) {
                 current[nextKey] = next[nextKey];
             }
         }
         for (const nextKey of nextKeys) {
+            AssertKey(nextKey);
             FromValue(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
         }
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.1.36",
+  "version": "1.1.37",
   "keywords": [
     "typescript",
     "jsonschema"