@sinclair/typebox 0.24.13 → 0.24.16

package/compiler/index.js

@@ -28,7 +28,11 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/conditional/conditional.d.ts

@@ -0,0 +1,17 @@
+import * as Types from '../typebox';
+export declare type TExtends<L extends Types.TSchema, R extends Types.TSchema, T extends Types.TSchema, U extends Types.TSchema> = Types.Static<L> extends Types.Static<R> ? T : U;
+export interface TExclude<T extends Types.TUnion, U extends Types.TUnion> extends Types.TUnion<any[]> {
+    static: Exclude<Types.Static<T, this['params']>, Types.Static<U, this['params']>>;
+}
+export interface TExtract<T extends Types.TSchema, U extends Types.TUnion> extends Types.TUnion<any[]> {
+    static: Extract<Types.Static<T, this['params']>, Types.Static<U, this['params']>>;
+}
+/** Provides Conditional Types */
+export declare namespace Conditional {
+    /** (Experimental) Creates a conditional expression type */
+    function Extends<L extends Types.TSchema, R extends Types.TSchema, T extends Types.TSchema, U extends Types.TSchema>(left: L, right: R, ok: T, fail: U): TExtends<L, R, T, U>;
+    /** (Experimental) Constructs a type by excluding from UnionType all union members that are assignable to ExcludedMembers. */
+    function Exclude<T extends Types.TUnion, U extends Types.TUnion>(unionType: T, excludedMembers: U, options?: Types.SchemaOptions): TExclude<T, U>;
+    /** (Experimental) Constructs a type by extracting from Type all union members that are assignable to Union. */
+    function Extract<T extends Types.TSchema, U extends Types.TUnion>(type: T, union: U, options?: Types.SchemaOptions): TExtract<T, U>;
+}

package/conditional/conditional.js

@@ -0,0 +1,91 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/conditional
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Conditional = void 0;
+const Types = require("../typebox");
+const structural_1 = require("./structural");
+const guard_1 = require("../guard");
+/** Provides Conditional Types */
+var Conditional;
+(function (Conditional) {
+    /** (Experimental) Creates a conditional expression type */
+    function Extends(left, right, ok, fail) {
+        switch (structural_1.Structural.Check(left, right)) {
+            case structural_1.StructuralResult.Union:
+                return Types.Type.Union([Clone(ok), Clone(fail)]);
+            case structural_1.StructuralResult.True:
+                return Clone(ok);
+            case structural_1.StructuralResult.False:
+                return Clone(fail);
+        }
+    }
+    Conditional.Extends = Extends;
+    /** (Experimental) Constructs a type by excluding from UnionType all union members that are assignable to ExcludedMembers. */
+    function Exclude(unionType, excludedMembers, options = {}) {
+        const anyOf = unionType.anyOf
+            .filter((schema) => {
+            const check = structural_1.Structural.Check(schema, excludedMembers);
+            return !(check === structural_1.StructuralResult.True || check === structural_1.StructuralResult.Union);
+        })
+            .map((schema) => Clone(schema));
+        return { ...options, [Types.Kind]: 'Union', anyOf };
+    }
+    Conditional.Exclude = Exclude;
+    /** (Experimental) Constructs a type by extracting from Type all union members that are assignable to Union. */
+    function Extract(type, union, options = {}) {
+        if (guard_1.TypeGuard.TUnion(type)) {
+            const anyOf = type.anyOf.filter((schema) => structural_1.Structural.Check(schema, union) === structural_1.StructuralResult.True).map((schema) => Clone(schema));
+            return { ...options, [Types.Kind]: 'Union', anyOf };
+        }
+        else {
+            const anyOf = union.anyOf.filter((schema) => structural_1.Structural.Check(type, schema) === structural_1.StructuralResult.True).map((schema) => Clone(schema));
+            return { ...options, [Types.Kind]: 'Union', anyOf };
+        }
+    }
+    Conditional.Extract = Extract;
+    function Clone(value) {
+        const isObject = (object) => typeof object === 'object' && object !== null && !Array.isArray(object);
+        const isArray = (object) => typeof object === 'object' && object !== null && Array.isArray(object);
+        if (isObject(value)) {
+            return Object.keys(value).reduce((acc, key) => ({
+                ...acc,
+                [key]: Clone(value[key]),
+            }), Object.getOwnPropertySymbols(value).reduce((acc, key) => ({
+                ...acc,
+                [key]: Clone(value[key]),
+            }), {}));
+        }
+        else if (isArray(value)) {
+            return value.map((item) => Clone(item));
+        }
+        else {
+            return value;
+        }
+    }
+})(Conditional = exports.Conditional || (exports.Conditional = {}));

package/conditional/index.d.ts

@@ -0,0 +1,2 @@
+export * from './conditional';
+export * from './structural';

package/conditional/index.js

@@ -0,0 +1,45 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/conditional
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./conditional"), exports);
+__exportStar(require("./structural"), exports);

package/conditional/structural.d.ts

@@ -0,0 +1,11 @@
+import * as Types from '../typebox';
+export declare enum StructuralResult {
+    Union = 0,
+    True = 1,
+    False = 2
+}
+/** Performs structural equivalence checks against TypeBox types. */
+export declare namespace Structural {
+    /** Structurally tests if the left schema extends the right. */
+    function Check(left: Types.TSchema, right: Types.TSchema): StructuralResult;
+}

package/conditional/structural.js

@@ -0,0 +1,654 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/conditional
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Structural = exports.StructuralResult = void 0;
+const Types = require("../typebox");
+const guard_1 = require("../guard");
+// --------------------------------------------------------------------------
+// StructuralResult
+// --------------------------------------------------------------------------
+var StructuralResult;
+(function (StructuralResult) {
+    StructuralResult[StructuralResult["Union"] = 0] = "Union";
+    StructuralResult[StructuralResult["True"] = 1] = "True";
+    StructuralResult[StructuralResult["False"] = 2] = "False";
+})(StructuralResult = exports.StructuralResult || (exports.StructuralResult = {}));
+// --------------------------------------------------------------------------
+// Structural
+// --------------------------------------------------------------------------
+/** Performs structural equivalence checks against TypeBox types. */
+var Structural;
+(function (Structural) {
+    const referenceMap = new Map();
+    // ------------------------------------------------------------------------
+    // Rules
+    // ------------------------------------------------------------------------
+    function AnyOrUnknownRule(right) {
+        // https://github.com/microsoft/TypeScript/issues/40049
+        if (right[Types.Kind] === 'Union' && right.anyOf.some((schema) => schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown'))
+            return true;
+        if (right[Types.Kind] === 'Unknown')
+            return true;
+        if (right[Types.Kind] === 'Any')
+            return true;
+        return false;
+    }
+    function ObjectRightRule(left, right) {
+        // type A = boolean extends {}     ? 1 : 2 // additionalProperties: false
+        // type B = boolean extends object ? 1 : 2 // additionalProperties: true
+        const additionalProperties = right.additionalProperties;
+        const propertyLength = globalThis.Object.keys(right.properties).length;
+        return additionalProperties === false && propertyLength === 0;
+    }
+    function UnionRightRule(left, right) {
+        const result = right.anyOf.some((right) => Visit(left, right) !== StructuralResult.False);
+        return result ? StructuralResult.True : StructuralResult.False;
+    }
+    // ------------------------------------------------------------------------
+    // Records
+    // ------------------------------------------------------------------------
+    function RecordPattern(schema) {
+        return globalThis.Object.keys(schema.patternProperties)[0];
+    }
+    function RecordNumberOrStringKey(schema) {
+        const pattern = RecordPattern(schema);
+        return pattern === '^.*$' || pattern === '^(0|[1-9][0-9]*)$';
+    }
+    function RecordValue(schema) {
+        const pattern = RecordPattern(schema);
+        return schema.patternProperties[pattern];
+    }
+    function RecordKey(schema) {
+        const pattern = RecordPattern(schema);
+        if (pattern === '^.*$') {
+            return Types.Type.String();
+        }
+        else if (pattern === '^(0|[1-9][0-9]*)$') {
+            return Types.Type.Number();
+        }
+        else {
+            const keys = pattern.slice(1, pattern.length - 1).split('|');
+            const schemas = keys.map((key) => (isNaN(+key) ? Types.Type.Literal(key) : Types.Type.Literal(parseFloat(key))));
+            return Types.Type.Union(schemas);
+        }
+    }
+    function PropertyMap(schema) {
+        const comparable = new Map();
+        if (guard_1.TypeGuard.TRecord(schema)) {
+            const propertyPattern = RecordPattern(schema);
+            if (propertyPattern === '^.*$' || propertyPattern === '^(0|[1-9][0-9]*)$')
+                throw Error('Cannot extract record properties without property constraints');
+            const propertySchema = schema.patternProperties[propertyPattern];
+            const propertyKeys = propertyPattern.slice(1, propertyPattern.length - 1).split('|');
+            propertyKeys.forEach((propertyKey) => {
+                comparable.set(propertyKey, propertySchema);
+            });
+        }
+        else {
+            globalThis.Object.entries(schema.properties).forEach(([propertyKey, propertySchema]) => {
+                comparable.set(propertyKey, propertySchema);
+            });
+        }
+        return comparable;
+    }
+    // ------------------------------------------------------------------------
+    // Indexable
+    // ------------------------------------------------------------------------
+    function Indexable(left, right) {
+        if (guard_1.TypeGuard.TUnion(right)) {
+            return StructuralResult.False;
+        }
+        else {
+            return Visit(left, right);
+        }
+    }
+    // ------------------------------------------------------------------------
+    // Checks
+    // ------------------------------------------------------------------------
+    function Any(left, right) {
+        return AnyOrUnknownRule(right) ? StructuralResult.True : StructuralResult.Union;
+    }
+    function Array(left, right) {
+        if (AnyOrUnknownRule(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TObject(right)) {
+            if (right.properties['length'] !== undefined && right.properties['length'][Types.Kind] === 'Number')
+                return StructuralResult.True;
+            if (globalThis.Object.keys(right.properties).length === 0)
+                return StructuralResult.True;
+            return StructuralResult.False;
+        }
+        else if (!guard_1.TypeGuard.TArray(right)) {
+            return StructuralResult.False;
+        }
+        else if (left.items === undefined && right.items !== undefined) {
+            return StructuralResult.False;
+        }
+        else if (left.items !== undefined && right.items === undefined) {
+            return StructuralResult.False;
+        }
+        else if (left.items === undefined && right.items === undefined) {
+            return StructuralResult.False;
+        }
+        else {
+            const result = Visit(left.items, right.items) !== StructuralResult.False;
+            return result ? StructuralResult.True : StructuralResult.False;
+        }
+    }
+    function Boolean(left, right) {
+        if (AnyOrUnknownRule(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TBoolean(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TUnion(right)) {
+            return UnionRightRule(left, right);
+        }
+        else {
+            return StructuralResult.False;
+        }
+    }
+    function Constructor(left, right) {
+        if (AnyOrUnknownRule(right)) {
+            return StructuralResult.True;
+        }
+        else if (!guard_1.TypeGuard.TConstructor(right)) {
+            return StructuralResult.False;
+        }
+        else if (right.parameters.length < left.parameters.length) {
+            return StructuralResult.False;
+        }
+        else {
+            if (Visit(left.returns, right.returns) === StructuralResult.False) {
+                return StructuralResult.False;
+            }
+            for (let i = 0; i < left.parameters.length; i++) {
+                const result = Visit(right.parameters[i], left.parameters[i]);
+                if (result === StructuralResult.False)
+                    return StructuralResult.False;
+            }
+            return StructuralResult.True;
+        }
+    }
+    function Function(left, right) {
+        if (AnyOrUnknownRule(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TObject(right)) {
+            if (right.properties['length'] !== undefined && right.properties['length'][Types.Kind] === 'Number')
+                return StructuralResult.True;
+            if (globalThis.Object.keys(right.properties).length === 0)
+                return StructuralResult.True;
+            return StructuralResult.False;
+        }
+        else if (!guard_1.TypeGuard.TFunction(right)) {
+            return StructuralResult.False;
+        }
+        else if (right.parameters.length < left.parameters.length) {
+            return StructuralResult.False;
+        }
+        else if (Visit(left.returns, right.returns) === StructuralResult.False) {
+            return StructuralResult.False;
+        }
+        else {
+            for (let i = 0; i < left.parameters.length; i++) {
+                const result = Visit(right.parameters[i], left.parameters[i]);
+                if (result === StructuralResult.False)
+                    return StructuralResult.False;
+            }
+            return StructuralResult.True;
+        }
+    }
+    function Integer(left, right) {
+        if (AnyOrUnknownRule(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TInteger(right) || guard_1.TypeGuard.TNumber(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TUnion(right)) {
+            return UnionRightRule(left, right);
+        }
+        else {
+            return StructuralResult.False;
+        }
+    }
+    function Literal(left, right) {
+        if (AnyOrUnknownRule(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TRecord(right)) {
+            if (typeof left.const === 'string') {
+                return Indexable(left, RecordValue(right));
+            }
+            else {
+                return StructuralResult.False;
+            }
+        }
+        else if (guard_1.TypeGuard.TLiteral(right) && left.const === right.const) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TString(right) && typeof left.const === 'string') {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TNumber(right) && typeof left.const === 'number') {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TInteger(right) && typeof left.const === 'number') {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TBoolean(right) && typeof left.const === 'boolean') {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TUnion(right)) {
+            return UnionRightRule(left, right);
+        }
+        else {
+            return StructuralResult.False;
+        }
+    }
+    function Number(left, right) {
+        if (AnyOrUnknownRule(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TNumber(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TInteger(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TUnion(right)) {
+            return UnionRightRule(left, right);
+        }
+        else {
+            return StructuralResult.False;
+        }
+    }
+    function Null(left, right) {
+        if (AnyOrUnknownRule(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TNull(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TUnion(right)) {
+            return UnionRightRule(left, right);
+        }
+        else {
+            return StructuralResult.False;
+        }
+    }
+    function Properties(left, right) {
+        if (right.size > left.size)
+            return StructuralResult.False;
+        if (![...right.keys()].every((rightKey) => left.has(rightKey)))
+            return StructuralResult.False;
+        for (const rightKey of right.keys()) {
+            const leftProp = left.get(rightKey);
+            const rightProp = right.get(rightKey);
+            if (Visit(leftProp, rightProp) === StructuralResult.False) {
+                return StructuralResult.False;
+            }
+        }
+        return StructuralResult.True;
+    }
+    function Object(left, right) {
+        if (AnyOrUnknownRule(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TObject(right)) {
+            return Properties(PropertyMap(left), PropertyMap(right));
+        }
+        else if (guard_1.TypeGuard.TRecord(right)) {
+            if (!RecordNumberOrStringKey(right)) {
+                return Properties(PropertyMap(left), PropertyMap(right));
+            }
+            else {
+                return StructuralResult.True;
+            }
+        }
+        else {
+            return StructuralResult.False;
+        }
+    }
+    function Promise(left, right) {
+        if (AnyOrUnknownRule(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TObject(right)) {
+            if (ObjectRightRule(left, right) || globalThis.Object.keys(right.properties).length === 0) {
+                return StructuralResult.True;
+            }
+            else {
+                return StructuralResult.False;
+            }
+        }
+        else if (!guard_1.TypeGuard.TPromise(right)) {
+            return StructuralResult.False;
+        }
+        else {
+            const result = Visit(left.item, right.item) !== StructuralResult.False;
+            return result ? StructuralResult.True : StructuralResult.False;
+        }
+    }
+    function Record(left, right) {
+        if (AnyOrUnknownRule(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TObject(right)) {
+            if (!RecordNumberOrStringKey(left)) {
+                return Properties(PropertyMap(left), PropertyMap(right));
+            }
+            else if (RecordPattern(left) === '^.*$') {
+                return StructuralResult.False;
+            }
+            else {
+                return globalThis.Object.keys(right.properties).length === 0 ? StructuralResult.True : StructuralResult.False;
+            }
+        }
+        else if (guard_1.TypeGuard.TRecord(right)) {
+            if (!RecordNumberOrStringKey(left) && !RecordNumberOrStringKey(right)) {
+                return Properties(PropertyMap(left), PropertyMap(right));
+            }
+            else if (RecordNumberOrStringKey(left) && !RecordNumberOrStringKey(right)) {
+                const leftKey = RecordKey(left);
+                const rightKey = RecordKey(right);
+                if (Visit(rightKey, leftKey) === StructuralResult.False) {
+                    return StructuralResult.False;
+                }
+                else {
+                    return StructuralResult.True;
+                }
+            }
+            else {
+                return StructuralResult.True;
+            }
+        }
+        else {
+            return StructuralResult.False;
+        }
+    }
+    function Ref(left, right) {
+        if (!referenceMap.has(left.$ref))
+            throw Error(`Cannot locate referenced $id '${left.$ref}'`);
+        const resolved = referenceMap.get(left.$ref);
+        return Visit(resolved, right);
+    }
+    function Self(left, right) {
+        if (!referenceMap.has(left.$ref))
+            throw Error(`Cannot locate referenced self $id '${left.$ref}'`);
+        const resolved = referenceMap.get(left.$ref);
+        return Visit(resolved, right);
+    }
+    function String(left, right) {
+        if (AnyOrUnknownRule(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TRecord(right)) {
+            return Indexable(left, RecordValue(right));
+        }
+        else if (guard_1.TypeGuard.TString(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TUnion(right)) {
+            return UnionRightRule(left, right);
+        }
+        else {
+            return StructuralResult.False;
+        }
+    }
+    function Tuple(left, right) {
+        if (AnyOrUnknownRule(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TObject(right)) {
+            const result = ObjectRightRule(left, right) || globalThis.Object.keys(right.properties).length === 0;
+            return result ? StructuralResult.True : StructuralResult.False;
+        }
+        else if (guard_1.TypeGuard.TRecord(right)) {
+            return Indexable(left, RecordValue(right));
+        }
+        else if (guard_1.TypeGuard.TArray(right)) {
+            if (right.items === undefined) {
+                return StructuralResult.False;
+            }
+            else if (guard_1.TypeGuard.TUnion(right.items) && left.items) {
+                const result = left.items.every((left) => UnionRightRule(left, right.items) !== StructuralResult.False);
+                return result ? StructuralResult.True : StructuralResult.False;
+            }
+            else if (guard_1.TypeGuard.TAny(right.items)) {
+                return StructuralResult.True;
+            }
+            else {
+                return StructuralResult.False;
+            }
+        }
+        if (!guard_1.TypeGuard.TTuple(right))
+            return StructuralResult.False;
+        if (left.items === undefined && right.items === undefined)
+            return StructuralResult.True;
+        if (left.items === undefined && right.items !== undefined)
+            return StructuralResult.False;
+        if (left.items !== undefined && right.items === undefined)
+            return StructuralResult.False;
+        if (left.items === undefined && right.items === undefined)
+            return StructuralResult.True;
+        if (left.minItems !== right.minItems || left.maxItems !== right.maxItems)
+            return StructuralResult.False;
+        for (let i = 0; i < left.items.length; i++) {
+            if (Visit(left.items[i], right.items[i]) === StructuralResult.False)
+                return StructuralResult.False;
+        }
+        return StructuralResult.True;
+    }
+    function Uint8Array(left, right) {
+        if (AnyOrUnknownRule(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TRecord(right)) {
+            return Indexable(left, RecordValue(right));
+        }
+        else if (guard_1.TypeGuard.TUint8Array(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TUnion(right)) {
+            return UnionRightRule(left, right);
+        }
+        else {
+            return StructuralResult.False;
+        }
+    }
+    function Undefined(left, right) {
+        if (AnyOrUnknownRule(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TUndefined(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TVoid(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TUnion(right)) {
+            return UnionRightRule(left, right);
+        }
+        else {
+            return StructuralResult.False;
+        }
+    }
+    function Union(left, right) {
+        if (left.anyOf.some((left) => guard_1.TypeGuard.TAny(left))) {
+            return StructuralResult.Union;
+        }
+        else if (guard_1.TypeGuard.TUnion(right)) {
+            const result = left.anyOf.every((left) => right.anyOf.some((right) => Visit(left, right) !== StructuralResult.False));
+            return result ? StructuralResult.True : StructuralResult.False;
+        }
+        else {
+            const result = left.anyOf.every((left) => Visit(left, right) !== StructuralResult.False);
+            return result ? StructuralResult.True : StructuralResult.False;
+        }
+    }
+    function Unknown(left, right) {
+        if (guard_1.TypeGuard.TUnion(right)) {
+            const result = right.anyOf.some((right) => guard_1.TypeGuard.TAny(right) || guard_1.TypeGuard.TUnknown(right));
+            return result ? StructuralResult.True : StructuralResult.False;
+        }
+        else if (guard_1.TypeGuard.TAny(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TUnknown(right)) {
+            return StructuralResult.True;
+        }
+        else {
+            return StructuralResult.False;
+        }
+    }
+    function Void(left, right) {
+        if (guard_1.TypeGuard.TUnion(right)) {
+            const result = right.anyOf.some((right) => guard_1.TypeGuard.TAny(right) || guard_1.TypeGuard.TUnknown(right));
+            return result ? StructuralResult.True : StructuralResult.False;
+        }
+        else if (guard_1.TypeGuard.TAny(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TUnknown(right)) {
+            return StructuralResult.True;
+        }
+        else if (guard_1.TypeGuard.TVoid(right)) {
+            return StructuralResult.True;
+        }
+        else {
+            return StructuralResult.False;
+        }
+    }
+    let recursionDepth = 0;
+    function Visit(left, right) {
+        recursionDepth += 1;
+        if (recursionDepth >= 1000)
+            return StructuralResult.True;
+        if (left.$id !== undefined)
+            referenceMap.set(left.$id, left);
+        if (right.$id !== undefined)
+            referenceMap.set(right.$id, right);
+        const resolvedRight = right[Types.Kind] === 'Self' ? referenceMap.get(right.$ref) : right;
+        if (guard_1.TypeGuard.TAny(left)) {
+            return Any(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TArray(left)) {
+            return Array(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TBoolean(left)) {
+            return Boolean(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TConstructor(left)) {
+            return Constructor(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TFunction(left)) {
+            return Function(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TInteger(left)) {
+            return Integer(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TLiteral(left)) {
+            return Literal(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TNull(left)) {
+            return Null(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TNumber(left)) {
+            return Number(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TObject(left)) {
+            return Object(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TPromise(left)) {
+            return Promise(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TRecord(left)) {
+            return Record(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TRef(left)) {
+            return Ref(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TSelf(left)) {
+            return Self(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TString(left)) {
+            return String(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TTuple(left)) {
+            return Tuple(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TUndefined(left)) {
+            return Undefined(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TUint8Array(left)) {
+            return Uint8Array(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TUnion(left)) {
+            return Union(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TUnknown(left)) {
+            return Unknown(left, resolvedRight);
+        }
+        else if (guard_1.TypeGuard.TVoid(left)) {
+            return Void(left, resolvedRight);
+        }
+        else {
+            throw Error(`Structural: Unknown left operand '${left[Types.Kind]}'`);
+        }
+    }
+    /** Structurally tests if the left schema extends the right. */
+    function Check(left, right) {
+        referenceMap.clear();
+        recursionDepth = 0;
+        return Visit(left, right);
+    }
+    Structural.Check = Check;
+})(Structural = exports.Structural || (exports.Structural = {}));

package/guard/guard.d.ts

@@ -1,5 +1,5 @@
 import * as Types from '../typebox';
-/** Structural checks for TypeBox types */
+/** TypeGuard tests that values conform to a known TypeBox type specification */
 export declare namespace TypeGuard {
     /** Returns true if the given schema is TAny */
     function TAny(schema: any): schema is Types.TAny;

package/guard/guard.js

@@ -29,7 +29,7 @@ THE SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeGuard = void 0;
 const Types = require("../typebox");
-/** Structural checks for TypeBox types */
+/** TypeGuard tests that values conform to a known TypeBox type specification */
 var TypeGuard;
 (function (TypeGuard) {
     function IsObject(schema) {
@@ -146,10 +146,10 @@ var TypeGuard;
     TypeGuard.TString = TString;
     /** Returns true if the given schema is TTuple */
     function TTuple(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Tuple' && schema.type === 'array' && schema.additionalItems === false && typeof schema.minItems === 'number' && typeof schema.maxItems === 'number' && schema.minItems === schema.maxItems)) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Tuple' && schema.type === 'array' && typeof schema.minItems === 'number' && typeof schema.maxItems === 'number' && schema.minItems === schema.maxItems)) {
             return false;
         }
-        if (schema.items === undefined && schema.minItems === 0) {
+        if (schema.items === undefined && schema.additionalItems === undefined && schema.minItems === 0) {
             return true;
         }
         if (!IsArray(schema.items)) {

package/guard/index.js

@@ -28,7 +28,11 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.13",
+  "version": "0.24.16",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "json-schema",
@@ -36,6 +36,6 @@
     "mocha": "^9.2.0",
     "prettier": "^2.7.1",
     "tsd": "^0.19.1",
-    "typescript": "^4.5.5"
+    "typescript": "^4.7.4"
   }
 }

package/readme.md

@@ -63,6 +63,7 @@ License MIT
 - [Recursive Types](#Recursive-Types)
 - [Generic Types](#Generic-Types)
 - [Unsafe Types](#Unsafe-Types)
+- [Conditional Types](#Conditional-Types)
 - [Values](#Values)
 - [Guards](#Guards)
 - [Strict](#Strict)
@@ -413,12 +414,12 @@ In addition to JSON schema types, TypeBox provides several extended types that a
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Constructor([   │ type T = new (              │ const T = {                    │
 │   Type.String(),               │  arg0: string,              │   type: 'constructor'          │
-│   Type.Number()                │  arg1: number               │   arguments: [{                │
+│   Type.Number()                │  arg1: number               │   parameters: [{               │
 │ ], Type.Boolean())             │ ) => boolean                │     type: 'string'             │
 │                                │                             │   }, {                         │
 │                                │                             │     type: 'number'             │
 │                                │                             │   }],                          │
-│                                │                             │   returns: {                   │
+│                                │                             │   return: {                    │
 │                                │                             │     type: 'boolean'            │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
@@ -426,12 +427,12 @@ In addition to JSON schema types, TypeBox provides several extended types that a
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Function([      │ type T = (                  │ const T = {                    │
 |   Type.String(),               │  arg0: string,              │   type : 'function',           │
-│   Type.Number()                │  arg1: number               │   arguments: [{                │
+│   Type.Number()                │  arg1: number               │   parameters: [{               │
 │ ], Type.Boolean())             │ ) => boolean                │     type: 'string'             │
 │                                │                             │   }, {                         │
 │                                │                             │     type: 'number'             │
 │                                │                             │   }],                          │
-│                                │                             │   returns: {                   │
+│                                │                             │   return: {                    │
 │                                │                             │     type: 'boolean'            │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
@@ -606,6 +607,57 @@ const T = StringEnum(['A', 'B', 'C'])                // const T = {
 type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
 ```
 
+<a name="Conditional-Types"></a>
+
+## Conditional Types
+
+Use `Conditional.Extends(...)` to create conditional mapped types.
+
+```typescript
+import { Conditional } from '@sinclair/typebox/conditional'
+```
+The following table shows the TypeBox mappings between TypeScript and JSON schema.
+
+```typescript
+┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
+│ TypeBox                        │ TypeScript                  │ Extended Schema                │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Conditional.Extends( │ type T =                    │ const T = {                    │
+│   Type.String(),               │  string extends number      │   const: false                 │
+│   Type.Number(),               │  true : false               │   type: 'boolean'              │
+│   Type.Literal(true)           │                             │ }                              │
+│   Type.Literal(false)          │                             │                                │
+│ )                              │                             │                                │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Conditional.Exclude( │ type T = Exclude<           │ const T = {                    │
+│   Type.Union([                 │   'a' | 'b' | 'c',          │   anyOf: [{                    │
+│     Type.Literal('a')          │   'a'                       │     const: 'b'                 │
+│     Type.Literal('b')          │ >                           │     type: 'string'             │
+│     Type.Literal('c')          │                             │   }, {                         │
+│   ]),                          │                             │     const: 'c'                 │
+│   Type.Union([                 │                             │     type: 'string'             │
+│     Type.Literal('a')          │                             │   }]                           │
+│   ])                           │                             │ }                              │
+│ )                              │                             │                                │
+│                                │                             │                                │
+└────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
+│ const T = Conditional.Extract( │ type T = Extract<           │ const T = {                    │
+│   Type.Union([                 │   'a' | 'b' | 'c',          │   anyOf: [{                    │
+│     Type.Literal('a')          │   'a' | 'f'                 │     const: 'a'                 │
+│     Type.Literal('b')          │ >                           │     type: 'string'             │
+│     Type.Literal('c')          │                             │   }]                           │
+│   ]),                          │                             │ }                              │
+│   Type.Union([                 │                             │                                │
+│     Type.Literal('a')          │                             │                                │
+│     Type.Literal('f')          │                             │                                │
+│   ])                           │                             │                                │
+│ )                              │                             │                                │
+│                                │                             │                                │
+└────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
+```
+
 <a name="Values"></a>
 
 ## Values

package/typebox.d.ts

@@ -63,12 +63,14 @@ export interface TBoolean extends TSchema {
     static: boolean;
     type: 'boolean';
 }
-export declare type TContructorParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
+export declare type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>;
+export declare type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
+export declare type StaticContructorParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
     [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
 }];
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Constructor';
-    static: new (...param: TContructorParameters<T, this['params']>) => Static<U, this['params']>;
+    static: new (...param: StaticContructorParameters<T, this['params']>) => Static<U, this['params']>;
     type: 'constructor';
     parameters: T;
     returns: U;
@@ -82,12 +84,14 @@ export interface TEnum<T extends Record<string, string | number> = Record<string
     static: T[keyof T];
     anyOf: TLiteral<string | number>[];
 }
-export declare type TFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
+export declare type TParameters<T extends TFunction> = TTuple<T['parameters']>;
+export declare type TReturnType<T extends TFunction> = T['returns'];
+export declare type StaticFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
     [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
 }];
 export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Function';
-    static: (...param: TFunctionParameters<T, this['params']>) => Static<U, this['params']>;
+    static: (...param: StaticFunctionParameters<T, this['params']>) => Static<U, this['params']>;
     type: 'function';
     parameters: T;
     returns: U;
@@ -293,12 +297,16 @@ export declare class TypeBuilder {
     Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T>;
     /** Creates a boolean type */
     Boolean(options?: SchemaOptions): TBoolean;
+    /** Creates a tuple type from this constructors parameters */
+    ConstructorParameters<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;
     /** Creates a constructor type */
     Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
     /** Creates a enum type */
     Enum<T extends Record<string, string | number>>(item: T, options?: SchemaOptions): TEnum<T>;
     /** Creates a function type */
     Function<T extends readonly TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
+    /** Creates a type from this constructors instance type */
+    InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;
     /** Creates a integer type */
     Integer(options?: NumericOptions): TInteger;
     /** Creates a intersect type. */
@@ -315,6 +323,8 @@ export declare class TypeBuilder {
     Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
     /** Creates a new object whose properties are omitted from the given object */
     Omit<T extends TObject, Properties extends Array<ObjectPropertyKeys<T>>>(schema: T, keys: [...Properties], options?: ObjectOptions): TOmit<T, Properties>;
+    /** Creates a tuple type from this functions parameters */
+    Parameters<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TParameters<T>;
     /** Creates an object type whose properties are all optional */
     Partial<T extends TObject>(schema: T, options?: ObjectOptions): TPartial<T>;
     /** Creates a new object whose properties are picked from the given object */
@@ -333,6 +343,8 @@ export declare class TypeBuilder {
     RegEx(regex: RegExp, options?: SchemaOptions): TString;
     /** Creates an object type whose properties are all required */
     Required<T extends TObject>(schema: T, options?: SchemaOptions): TRequired<T>;
+    /** Creates a type from this functions return type */
+    ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
     /** Removes Kind and Modifier symbol property keys from this schema */
     Strict<T extends TSchema>(schema: T): T;
     /** Creates a string type */

package/typebox.js

@@ -68,6 +68,10 @@ class TypeBuilder {
     Boolean(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Boolean', type: 'boolean' });
     }
+    /** Creates a tuple type from this constructors parameters */
+    ConstructorParameters(schema, options = {}) {
+        return this.Tuple([...schema.parameters], { ...options });
+    }
     /** Creates a constructor type */
     Constructor(parameters, returns, options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'constructor', parameters, returns });
@@ -84,6 +88,10 @@ class TypeBuilder {
     Function(parameters, returns, options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Function', type: 'function', parameters, returns });
     }
+    /** Creates a type from this constructors instance type */
+    InstanceType(schema, options = {}) {
+        return { ...options, ...this.Clone(schema.returns) };
+    }
     /** Creates a integer type */
     Integer(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Integer', type: 'integer' });
@@ -160,6 +168,10 @@ class TypeBuilder {
         }
         return this.Create(next);
     }
+    /** Creates a tuple type from this functions parameters */
+    Parameters(schema, options = {}) {
+        return exports.Type.Tuple(schema.parameters, { ...options });
+    }
     /** Creates an object type whose properties are all optional */
     Partial(schema, options = {}) {
         const next = { ...this.Clone(schema), ...options };
@@ -258,6 +270,10 @@ class TypeBuilder {
         }
         return this.Create(next);
     }
+    /** Creates a type from this functions return type */
+    ReturnType(schema, options = {}) {
+        return { ...options, ...this.Clone(schema.returns) };
+    }
     /** Removes Kind and Modifier symbol property keys from this schema */
     Strict(schema) {
         return JSON.parse(JSON.stringify(schema));

package/value/cast.js

@@ -32,9 +32,10 @@ const Types = require("../typebox");
 const create_1 = require("./create");
 const check_1 = require("./check");
 // --------------------------------------------------------------------------
-// Specialized Union Patch. Because a value can be one of many different
-// unions with properties potentially overlapping, we need a strategy
-// in which to resolve the appropriate schema to patch from.
+// Specialized Union Cast. Because a union can be one of many varying types
+// with properties potentially overlapping, we need a strategy to determine
+// which of those types we should cast into. This strategy needs to factor
+// the value provided by the user to make this decision.
 //
 // The following will score each union type found within the types anyOf
 // array. Typically this is executed for objects only, so the score is a

package/value/index.js

@@ -28,7 +28,11 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];