@highstate/designer 0.2.0 → 0.2.1

package/.output/server/node_modules/@pulumi/query/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@pulumi/query",
+  "version": "v0.3.0",
+  "description": "An simple, relational SDK for querying TypeScript and JavaScript data structures",
+  "license": "Apache-2.0",
+  "keywords": [
+    "linq",
+    "query",
+    "rxjs"
+  ],
+  "homepage": "https://pulumi.io",
+  "repository": "https://github.com/pulumi/pulumi-query",
+  "dependencies": {},
+  "devDependencies": {
+    "@types/mocha": "^2.2.42",
+    "@types/node": "^10.12.7",
+    "istanbul": "^0.4.5",
+    "mocha": "^3.5.0",
+    "tslint": "^5.11.0",
+    "typescript": "^3.0.0"
+  }
+}

package/.output/server/node_modules/@pulumi/query/sources.js

@@ -0,0 +1,81 @@
+"use strict";
+// Copyright 2016-2019, Pulumi Corporation.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const interfaces_1 = require("./interfaces");
+const util_1 = require("./util");
+function range(start, end) {
+    return __asyncGenerator(this, arguments, function* range_1() {
+        let i = start;
+        while (true) {
+            if (end !== undefined && i >= end) {
+                return yield __await(void 0);
+            }
+            yield yield __await(i++);
+        }
+    });
+}
+exports.range = range;
+function from(source) {
+    return __asyncGenerator(this, arguments, function* from_1() {
+        var e_1, _a;
+        let iter;
+        if (util_1.isIterable(source) || interfaces_1.isAsyncIterable(source)) {
+            iter = source;
+        }
+        else {
+            iter = yield __await(source);
+        }
+        if (util_1.isIterable(iter)) {
+            for (const t of iter) {
+                yield yield __await(t);
+            }
+        }
+        else {
+            try {
+                for (var iter_1 = __asyncValues(iter), iter_1_1; iter_1_1 = yield __await(iter_1.next()), !iter_1_1.done;) {
+                    const t = iter_1_1.value;
+                    yield yield __await(t);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (iter_1_1 && !iter_1_1.done && (_a = iter_1.return)) yield __await(_a.call(iter_1));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+    });
+}
+exports.from = from;

package/.output/server/node_modules/@pulumi/query/util.js

@@ -0,0 +1,23 @@
+"use strict";
+// Copyright 2016-2019, Pulumi Corporation.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+function isAsyncIterable(o) {
+    return typeof o[Symbol.asyncIterator] === "function";
+}
+exports.isAsyncIterable = isAsyncIterable;
+function isIterable(o) {
+    return typeof o[Symbol.iterator] === "function";
+}
+exports.isIterable = isIterable;

package/.output/server/node_modules/@sinclair/typebox/build/esm/index.mjs

@@ -0,0 +1,78 @@
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+export * from './type/clone/index.mjs';
+export * from './type/create/index.mjs';
+export * from './type/error/index.mjs';
+export * from './type/guard/index.mjs';
+export * from './type/helpers/index.mjs';
+export * from './type/patterns/index.mjs';
+export * from './type/registry/index.mjs';
+export * from './type/sets/index.mjs';
+export * from './type/symbols/index.mjs';
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+export * from './type/any/index.mjs';
+export * from './type/array/index.mjs';
+export * from './type/async-iterator/index.mjs';
+export * from './type/awaited/index.mjs';
+export * from './type/bigint/index.mjs';
+export * from './type/boolean/index.mjs';
+export * from './type/composite/index.mjs';
+export * from './type/const/index.mjs';
+export * from './type/constructor/index.mjs';
+export * from './type/constructor-parameters/index.mjs';
+export * from './type/date/index.mjs';
+export * from './type/enum/index.mjs';
+export * from './type/exclude/index.mjs';
+export * from './type/extends/index.mjs';
+export * from './type/extract/index.mjs';
+export * from './type/function/index.mjs';
+export * from './type/indexed/index.mjs';
+export * from './type/instance-type/index.mjs';
+export * from './type/integer/index.mjs';
+export * from './type/intersect/index.mjs';
+export * from './type/iterator/index.mjs';
+export * from './type/intrinsic/index.mjs';
+export * from './type/keyof/index.mjs';
+export * from './type/literal/index.mjs';
+export * from './type/module/index.mjs';
+export * from './type/mapped/index.mjs';
+export * from './type/never/index.mjs';
+export * from './type/not/index.mjs';
+export * from './type/null/index.mjs';
+export * from './type/number/index.mjs';
+export * from './type/object/index.mjs';
+export * from './type/omit/index.mjs';
+export * from './type/optional/index.mjs';
+export * from './type/parameters/index.mjs';
+export * from './type/partial/index.mjs';
+export * from './type/pick/index.mjs';
+export * from './type/promise/index.mjs';
+export * from './type/readonly/index.mjs';
+export * from './type/readonly-optional/index.mjs';
+export * from './type/record/index.mjs';
+export * from './type/recursive/index.mjs';
+export * from './type/ref/index.mjs';
+export * from './type/regexp/index.mjs';
+export * from './type/required/index.mjs';
+export * from './type/rest/index.mjs';
+export * from './type/return-type/index.mjs';
+export * from './type/schema/index.mjs';
+export * from './type/static/index.mjs';
+export * from './type/string/index.mjs';
+export * from './type/symbol/index.mjs';
+export * from './type/template-literal/index.mjs';
+export * from './type/transform/index.mjs';
+export * from './type/tuple/index.mjs';
+export * from './type/uint8array/index.mjs';
+export * from './type/undefined/index.mjs';
+export * from './type/union/index.mjs';
+export * from './type/unknown/index.mjs';
+export * from './type/unsafe/index.mjs';
+export * from './type/void/index.mjs';
+// ------------------------------------------------------------------
+// Type.*
+// ------------------------------------------------------------------
+export * from './type/type/index.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/system/policy.mjs

@@ -0,0 +1,54 @@
+import { IsObject, IsArray, IsNumber, IsUndefined } from '../value/guard/index.mjs';
+export var TypeSystemPolicy;
+(function (TypeSystemPolicy) {
+    // ------------------------------------------------------------------
+    // TypeSystemPolicy: Instancing
+    // ------------------------------------------------------------------
+    /**
+     * Configures the instantiation behavior of TypeBox types. The `default` option assigns raw JavaScript
+     * references for embedded types, which may cause side effects if type properties are explicitly updated
+     * outside the TypeBox type builder. The `clone` option creates copies of any shared types upon creation,
+     * preventing unintended side effects. The `freeze` option applies `Object.freeze()` to the type, making
+     * it fully readonly and immutable. Implementations should use `default` whenever possible, as it is the
+     * fastest way to instantiate types. The default setting is `default`.
+     */
+    TypeSystemPolicy.InstanceMode = 'default';
+    // ------------------------------------------------------------------
+    // TypeSystemPolicy: Checking
+    // ------------------------------------------------------------------
+    /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
+    TypeSystemPolicy.ExactOptionalPropertyTypes = false;
+    /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
+    TypeSystemPolicy.AllowArrayObject = false;
+    /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
+    TypeSystemPolicy.AllowNaN = false;
+    /** Sets whether `null` should validate for void types. The default is `false` */
+    TypeSystemPolicy.AllowNullVoid = false;
+    /** Checks this value using the ExactOptionalPropertyTypes policy */
+    function IsExactOptionalProperty(value, key) {
+        return TypeSystemPolicy.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
+    }
+    TypeSystemPolicy.IsExactOptionalProperty = IsExactOptionalProperty;
+    /** Checks this value using the AllowArrayObjects policy */
+    function IsObjectLike(value) {
+        const isObject = IsObject(value);
+        return TypeSystemPolicy.AllowArrayObject ? isObject : isObject && !IsArray(value);
+    }
+    TypeSystemPolicy.IsObjectLike = IsObjectLike;
+    /** Checks this value as a record using the AllowArrayObjects policy */
+    function IsRecordLike(value) {
+        return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
+    }
+    TypeSystemPolicy.IsRecordLike = IsRecordLike;
+    /** Checks this value using the AllowNaN policy */
+    function IsNumberLike(value) {
+        return TypeSystemPolicy.AllowNaN ? IsNumber(value) : Number.isFinite(value);
+    }
+    TypeSystemPolicy.IsNumberLike = IsNumberLike;
+    /** Checks this value using the AllowVoidNull policy */
+    function IsVoidLike(value) {
+        const isUndefined = IsUndefined(value);
+        return TypeSystemPolicy.AllowNullVoid ? isUndefined || value === null : isUndefined;
+    }
+    TypeSystemPolicy.IsVoidLike = IsVoidLike;
+})(TypeSystemPolicy || (TypeSystemPolicy = {}));

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/any/any.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates an Any type */
+export function Any(options) {
+    return CreateType({ [Kind]: 'Any' }, options);
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/any/index.mjs

@@ -0,0 +1 @@
+export * from './any.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/array/array.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates an Array type */
+export function Array(items, options) {
+    return CreateType({ [Kind]: 'Array', type: 'array', items }, options);
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/array/index.mjs

@@ -0,0 +1 @@
+export * from './array.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/async-iterator/async-iterator.mjs

@@ -0,0 +1,6 @@
+import { Kind } from '../symbols/index.mjs';
+import { CreateType } from '../create/type.mjs';
+/** `[JavaScript]` Creates a AsyncIterator type */
+export function AsyncIterator(items, options) {
+    return CreateType({ [Kind]: 'AsyncIterator', type: 'AsyncIterator', items }, options);
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/async-iterator/index.mjs

@@ -0,0 +1 @@
+export * from './async-iterator.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/awaited/awaited.mjs

@@ -0,0 +1,37 @@
+import { CreateType } from '../create/type.mjs';
+import { Computed } from '../computed/index.mjs';
+import { Intersect } from '../intersect/index.mjs';
+import { Union } from '../union/index.mjs';
+import { Ref } from '../ref/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsIntersect, IsUnion, IsPromise, IsRef, IsComputed } from '../guard/kind.mjs';
+// prettier-ignore
+function FromComputed(target, parameters) {
+    return Computed('Awaited', [Computed(target, parameters)]);
+}
+// prettier-ignore
+function FromRef($ref) {
+    return Computed('Awaited', [Ref($ref)]);
+}
+// prettier-ignore
+function FromIntersect(types) {
+    return Intersect(FromRest(types));
+}
+// prettier-ignore
+function FromUnion(types) {
+    return Union(FromRest(types));
+}
+// prettier-ignore
+function FromPromise(type) {
+    return Awaited(type);
+}
+// prettier-ignore
+function FromRest(types) {
+    return types.map(type => Awaited(type));
+}
+/** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
+export function Awaited(type, options) {
+    return CreateType(IsComputed(type) ? FromComputed(type.target, type.parameters) : IsIntersect(type) ? FromIntersect(type.allOf) : IsUnion(type) ? FromUnion(type.anyOf) : IsPromise(type) ? FromPromise(type.item) : IsRef(type) ? FromRef(type.$ref) : type, options);
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/awaited/index.mjs

@@ -0,0 +1 @@
+export * from './awaited.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/bigint/bigint.mjs

@@ -0,0 +1,6 @@
+import { Kind } from '../symbols/index.mjs';
+import { CreateType } from '../create/index.mjs';
+/** `[JavaScript]` Creates a BigInt type */
+export function BigInt(options) {
+    return CreateType({ [Kind]: 'BigInt', type: 'bigint' }, options);
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/bigint/index.mjs

@@ -0,0 +1 @@
+export * from './bigint.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/boolean/boolean.mjs

@@ -0,0 +1,6 @@
+import { Kind } from '../symbols/index.mjs';
+import { CreateType } from '../create/index.mjs';
+/** `[Json]` Creates a Boolean type */
+export function Boolean(options) {
+    return CreateType({ [Kind]: 'Boolean', type: 'boolean' }, options);
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/boolean/index.mjs

@@ -0,0 +1 @@
+export * from './boolean.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/clone/index.mjs

@@ -0,0 +1,2 @@
+export * from './type.mjs';
+export * from './value.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/clone/type.mjs

@@ -0,0 +1,9 @@
+import { Clone } from './value.mjs';
+/** Clones a Rest */
+export function CloneRest(schemas) {
+    return schemas.map((schema) => CloneType(schema));
+}
+/** Clones a Type */
+export function CloneType(schema, options) {
+    return options === undefined ? Clone(schema) : Clone({ ...options, ...schema });
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/clone/value.mjs

@@ -0,0 +1,36 @@
+import * as ValueGuard from '../guard/value.mjs';
+function ArrayType(value) {
+    return value.map((value) => Visit(value));
+}
+function DateType(value) {
+    return new Date(value.getTime());
+}
+function Uint8ArrayType(value) {
+    return new Uint8Array(value);
+}
+function RegExpType(value) {
+    return new RegExp(value.source, value.flags);
+}
+function ObjectType(value) {
+    const result = {};
+    for (const key of Object.getOwnPropertyNames(value)) {
+        result[key] = Visit(value[key]);
+    }
+    for (const key of Object.getOwnPropertySymbols(value)) {
+        result[key] = Visit(value[key]);
+    }
+    return result;
+}
+// prettier-ignore
+function Visit(value) {
+    return (ValueGuard.IsArray(value) ? ArrayType(value) :
+        ValueGuard.IsDate(value) ? DateType(value) :
+            ValueGuard.IsUint8Array(value) ? Uint8ArrayType(value) :
+                ValueGuard.IsRegExp(value) ? RegExpType(value) :
+                    ValueGuard.IsObject(value) ? ObjectType(value) :
+                        value);
+}
+/** Clones a value */
+export function Clone(value) {
+    return Visit(value);
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/composite/composite.mjs

@@ -0,0 +1,42 @@
+import { IntersectEvaluated } from '../intersect/index.mjs';
+import { IndexFromPropertyKeys } from '../indexed/index.mjs';
+import { KeyOfPropertyKeys } from '../keyof/index.mjs';
+import { Object } from '../object/index.mjs';
+import { SetDistinct } from '../sets/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsNever } from '../guard/kind.mjs';
+// prettier-ignore
+function CompositeKeys(T) {
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...KeyOfPropertyKeys(L));
+    return SetDistinct(Acc);
+}
+// prettier-ignore
+function FilterNever(T) {
+    return T.filter(L => !IsNever(L));
+}
+// prettier-ignore
+function CompositeProperty(T, K) {
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...IndexFromPropertyKeys(L, [K]));
+    return FilterNever(Acc);
+}
+// prettier-ignore
+function CompositeProperties(T, K) {
+    const Acc = {};
+    for (const L of K) {
+        Acc[L] = IntersectEvaluated(CompositeProperty(T, L));
+    }
+    return Acc;
+}
+// prettier-ignore
+export function Composite(T, options) {
+    const K = CompositeKeys(T);
+    const P = CompositeProperties(T, K);
+    const R = Object(P, options);
+    return R;
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/composite/index.mjs

@@ -0,0 +1 @@
+export * from './composite.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/computed/computed.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/index.mjs';
+import { Kind } from '../symbols/symbols.mjs';
+/** `[Internal]` Creates a deferred computed type. This type is used exclusively in modules to defer resolution of computable types that contain interior references  */
+export function Computed(target, parameters, options) {
+    return CreateType({ [Kind]: 'Computed', target, parameters }, options);
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/computed/index.mjs

@@ -0,0 +1 @@
+export * from './computed.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/const/const.mjs

@@ -0,0 +1,54 @@
+import { Any } from '../any/index.mjs';
+import { BigInt } from '../bigint/index.mjs';
+import { Date } from '../date/index.mjs';
+import { Function as FunctionType } from '../function/index.mjs';
+import { Literal } from '../literal/index.mjs';
+import { Null } from '../null/index.mjs';
+import { Object } from '../object/index.mjs';
+import { Symbol } from '../symbol/index.mjs';
+import { Tuple } from '../tuple/index.mjs';
+import { Readonly } from '../readonly/index.mjs';
+import { Undefined } from '../undefined/index.mjs';
+import { Uint8Array } from '../uint8array/index.mjs';
+import { Unknown } from '../unknown/index.mjs';
+import { CreateType } from '../create/index.mjs';
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsArray, IsNumber, IsBigInt, IsUint8Array, IsDate, IsIterator, IsObject, IsAsyncIterator, IsFunction, IsUndefined, IsNull, IsSymbol, IsBoolean, IsString } from '../guard/value.mjs';
+// prettier-ignore
+function FromArray(T) {
+    return T.map(L => FromValue(L, false));
+}
+// prettier-ignore
+function FromProperties(value) {
+    const Acc = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(value))
+        Acc[K] = Readonly(FromValue(value[K], false));
+    return Acc;
+}
+function ConditionalReadonly(T, root) {
+    return (root === true ? T : Readonly(T));
+}
+// prettier-ignore
+function FromValue(value, root) {
+    return (IsAsyncIterator(value) ? ConditionalReadonly(Any(), root) :
+        IsIterator(value) ? ConditionalReadonly(Any(), root) :
+            IsArray(value) ? Readonly(Tuple(FromArray(value))) :
+                IsUint8Array(value) ? Uint8Array() :
+                    IsDate(value) ? Date() :
+                        IsObject(value) ? ConditionalReadonly(Object(FromProperties(value)), root) :
+                            IsFunction(value) ? ConditionalReadonly(FunctionType([], Unknown()), root) :
+                                IsUndefined(value) ? Undefined() :
+                                    IsNull(value) ? Null() :
+                                        IsSymbol(value) ? Symbol() :
+                                            IsBigInt(value) ? BigInt() :
+                                                IsNumber(value) ? Literal(value) :
+                                                    IsBoolean(value) ? Literal(value) :
+                                                        IsString(value) ? Literal(value) :
+                                                            Object({}));
+}
+/** `[JavaScript]` Creates a readonly const type from the given value. */
+export function Const(T, options) {
+    return CreateType(FromValue(T, true), options);
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/const/index.mjs

@@ -0,0 +1 @@
+export * from './const.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/constructor/constructor.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[JavaScript]` Creates a Constructor type */
+export function Constructor(parameters, returns, options) {
+    return CreateType({ [Kind]: 'Constructor', type: 'Constructor', parameters, returns }, options);
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/constructor/index.mjs

@@ -0,0 +1 @@
+export * from './constructor.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/constructor-parameters.mjs

@@ -0,0 +1,5 @@
+import { Tuple } from '../tuple/index.mjs';
+/** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
+export function ConstructorParameters(schema, options) {
+    return Tuple(schema.parameters, options);
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/index.mjs

@@ -0,0 +1 @@
+export * from './constructor-parameters.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/create/immutable.mjs

@@ -0,0 +1,33 @@
+import * as ValueGuard from '../guard/value.mjs';
+function ImmutableArray(value) {
+    return globalThis.Object.freeze(value).map((value) => Immutable(value));
+}
+function ImmutableDate(value) {
+    return value;
+}
+function ImmutableUint8Array(value) {
+    return value;
+}
+function ImmutableRegExp(value) {
+    return value;
+}
+function ImmutableObject(value) {
+    const result = {};
+    for (const key of Object.getOwnPropertyNames(value)) {
+        result[key] = Immutable(value[key]);
+    }
+    for (const key of Object.getOwnPropertySymbols(value)) {
+        result[key] = Immutable(value[key]);
+    }
+    return globalThis.Object.freeze(result);
+}
+/** Specialized deep immutable value. Applies freeze recursively to the given value */
+// prettier-ignore
+export function Immutable(value) {
+    return (ValueGuard.IsArray(value) ? ImmutableArray(value) :
+        ValueGuard.IsDate(value) ? ImmutableDate(value) :
+            ValueGuard.IsUint8Array(value) ? ImmutableUint8Array(value) :
+                ValueGuard.IsRegExp(value) ? ImmutableRegExp(value) :
+                    ValueGuard.IsObject(value) ? ImmutableObject(value) :
+                        value);
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/create/index.mjs

@@ -0,0 +1 @@
+export * from './type.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/create/type.mjs

@@ -0,0 +1,15 @@
+import { TypeSystemPolicy } from '../../system/policy.mjs';
+import { Immutable } from './immutable.mjs';
+import { Clone } from '../clone/value.mjs';
+/** Creates TypeBox schematics using the configured InstanceMode */
+export function CreateType(schema, options) {
+    const result = options !== undefined ? { ...options, ...schema } : schema;
+    switch (TypeSystemPolicy.InstanceMode) {
+        case 'freeze':
+            return Immutable(result);
+        case 'clone':
+            return Clone(result);
+        default:
+            return result;
+    }
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/date/date.mjs

@@ -0,0 +1,6 @@
+import { Kind } from '../symbols/index.mjs';
+import { CreateType } from '../create/type.mjs';
+/** `[JavaScript]` Creates a Date type */
+export function Date(options) {
+    return CreateType({ [Kind]: 'Date', type: 'Date' }, options);
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/date/index.mjs

@@ -0,0 +1 @@
+export * from './date.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/discard/discard.mjs

@@ -0,0 +1,8 @@
+function DiscardKey(value, key) {
+    const { [key]: _, ...rest } = value;
+    return rest;
+}
+/** Discards property keys from the given value. This function returns a shallow Clone. */
+export function Discard(value, keys) {
+    return keys.reduce((acc, key) => DiscardKey(acc, key), value);
+}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/discard/index.mjs

@@ -0,0 +1 @@
+export * from './discard.mjs';