typebox 0.0.1 → 1.0.0

package/build/schema/types/ref.mjs

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid $ref property
+ * @specification Json Schema 7
+ */
+export function IsRef(schema) {
+    return Guard.HasPropertyKey(schema, '$ref')
+        && Guard.IsString(schema.$ref);
+}

package/build/schema/types/required.d.mts

@@ -0,0 +1,9 @@
+import { type XSchema } from './schema.mjs';
+export interface XRequired<Required extends string[] = string[]> {
+    required: Required;
+}
+/**
+ * Returns true if the schema contains a valid required property
+ * @specification Json Schema 7
+ */
+export declare function IsRequired(schema: XSchema): schema is XRequired;

package/build/schema/types/required.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid required property
+ * @specification Json Schema 7
+ */
+export function IsRequired(schema) {
+    return Guard.HasPropertyKey(schema, 'required')
+        && Guard.IsArray(schema.required)
+        && schema.required.every(value => Guard.IsString(value));
+}

package/build/schema/types/schema.d.mts

@@ -0,0 +1,9 @@
+export type XSchema = object;
+/** Returns true if this value is object like */
+export declare function IsSchema(value: unknown): value is XSchema;
+export type XSchemaBoolean = boolean;
+/** Returns true if this value is a boolean */
+export declare function IsBooleanSchema(value: unknown): value is XSchemaBoolean;
+export type XSchemaLike = XSchema | XSchemaBoolean;
+/** Returns true if this value is schema like */
+export declare function IsSchemaLike(value: unknown): value is XSchemaLike;

package/build/schema/types/schema.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+/** Returns true if this value is object like */
+export function IsSchema(value) {
+    return Guard.IsObject(value) && !Guard.IsArray(value);
+}
+/** Returns true if this value is a boolean */
+export function IsBooleanSchema(value) {
+    return Guard.IsBoolean(value);
+}
+/** Returns true if this value is schema like */
+export function IsSchemaLike(value) {
+    return IsSchema(value) || IsBooleanSchema(value);
+}

package/build/schema/types/static.d.mts

@@ -0,0 +1,115 @@
+import type { XSchemaLike } from '../types/schema.mjs';
+import type { XStandardSchemaV1, XStandardValidatorV1 } from './_standard.mjs';
+import type { XAdditionalProperties } from './additionalProperties.mjs';
+import type { XAnyOf } from './anyOf.mjs';
+import type { XAllOf } from './allOf.mjs';
+import type { XConst } from './const.mjs';
+import type { XEnum } from './enum.mjs';
+import type { XItems } from './items.mjs';
+import type { XOneOf } from './oneOf.mjs';
+import type { XPatternProperties } from './patternProperties.mjs';
+import type { XPrefixItems } from './prefixItems.mjs';
+import type { XProperties } from './properties.mjs';
+import type { XRequired } from './required.mjs';
+export type StaticXStandardSchemaV1<Validator extends XStandardValidatorV1, ValidateResult extends unknown = ReturnType<Validator['validate']>, RemoveAsync extends unknown = Exclude<ValidateResult, Promise<any>>, RemoveIssue extends unknown = Exclude<RemoveAsync, {
+    issues: any;
+}>, Result extends unknown = RemoveIssue extends {
+    value: infer Value;
+} ? Value : unknown> = Result;
+type StaticXAdditionalProperties<Schema extends XSchemaLike, Result extends Record<PropertyKey, unknown> = (Schema extends true ? {
+    [key: string]: unknown;
+} : Schema extends false ? {} : {
+    [key: string]: XStatic<Schema>;
+})> = Result;
+type StaticXAllOf<Schemas extends XSchemaLike[], Result extends unknown = unknown> = Schemas extends [infer Left extends XSchemaLike, ...infer Right extends XSchemaLike[]] ? StaticXAllOf<Right, XStatic<Left> & Result> : Result;
+type StaticXAnyOf<Schemas extends XSchemaLike[], Result extends unknown = never> = Schemas extends [infer Left extends XSchemaLike, ...infer Right extends XSchemaLike[]] ? StaticXAnyOf<Right, XStatic<Left> | Result> : Result;
+type StaticXConst<Value extends unknown> = Value;
+type StaticXEnum<Values extends unknown[], Result extends unknown = never> = Values extends [infer Left extends unknown, ...infer Right extends unknown[]] ? StaticXEnum<Right, Left | Result> : Result;
+type StaticXItemsUnsized<Schema extends XSchemaLike> = XStatic<Schema>[];
+type StaticXItemsSized<Schema extends XSchemaLike[], Result extends unknown[] = []> = Schema extends [infer Left extends XSchemaLike, ...infer Right extends XSchemaLike[]] ? StaticXItemsSized<Right, [...Result, XStatic<Left>]> : Result;
+type StaticXItems<Schemas extends XSchemaLike[] | XSchemaLike, Result extends unknown = (Schemas extends XSchemaLike[] ? StaticXItemsSized<[...Schemas]> : Schemas extends XSchemaLike ? StaticXItemsUnsized<Schemas> : never)> = Result;
+type StaticXOneOf<Schemas extends XSchemaLike[], Result extends unknown = never> = Schemas extends [infer Left extends XSchemaLike, ...infer Right extends XSchemaLike[]] ? StaticXOneOf<Right, XStatic<Left> | Result> : Result;
+type StaticXPatternProperties<Properties extends Record<PropertyKey, XSchemaLike> = Record<PropertyKey, XSchemaLike>, InferredProperties extends Record<PropertyKey, unknown> = {
+    [Key in keyof Properties]: XStatic<Properties[Key]>;
+}, EvaluatedProperties extends unknown = {
+    [key: string]: InferredProperties[keyof InferredProperties];
+}> = EvaluatedProperties;
+type StaticXPrefixItems<Schemas extends XSchemaLike[], Result extends unknown[] = []> = Schemas extends [infer Left extends XSchemaLike, ...infer Right extends XSchemaLike[]] ? StaticXPrefixItems<Right, [...Result, XStatic<Left>]> : Result;
+type StaticXProperties<Properties extends Record<PropertyKey, XSchemaLike>, Readonly extends Record<PropertyKey, unknown> = {
+    readonly [Key in keyof Properties as Properties[Key] extends {
+        readOnly: true;
+    } ? Key : never]?: XStatic<Properties[Key]>;
+}, Standard extends Record<PropertyKey, unknown> = {
+    [Key in keyof Properties as Properties[Key] extends {
+        readOnly: true;
+    } ? never : Key]?: XStatic<Properties[Key]>;
+}, Result extends Record<PropertyKey, unknown> = Readonly & Standard> = Result;
+type RequiredSelectProperty<Properties extends Record<PropertyKey, XSchemaLike>, Key extends string, Result extends Record<PropertyKey, unknown> = (Key extends keyof Properties ? Properties[Key] extends {
+    readOnly: true;
+} ? {
+    readonly [_ in Key]: XStatic<Properties[Key]>;
+} : {
+    [_ in Key]: XStatic<Properties[Key]>;
+} : {
+    [_ in Key]: unknown;
+})> = Result;
+type RequiredSelectProperties<Properties extends Record<PropertyKey, XSchemaLike>, Keys extends string[], Result extends Record<PropertyKey, unknown> = {}> = Keys extends [infer Left extends string, ...infer Right extends string[]] ? RequiredSelectProperties<Properties, Right, Result & RequiredSelectProperty<Properties, Left>> : Result;
+type RequiredGetProperties<Schema extends XSchemaLike, Result extends Record<PropertyKey, unknown> = (Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchemaLike>> ? Properties : {})> = Result;
+type StaticXRequired<Schema extends XSchemaLike, Keys extends string[], Properties extends Record<PropertyKey, XSchemaLike> = RequiredGetProperties<Schema>, Result extends Record<PropertyKey, unknown> = RequiredSelectProperties<Properties, Keys>> = Result;
+type StaticXKeywords<Schema, Result extends unknown[] = [
+    Schema extends XAdditionalProperties<infer Type extends XSchemaLike> ? StaticXAdditionalProperties<Type> : unknown,
+    Schema extends XAllOf<infer Types extends XSchemaLike[]> ? StaticXAllOf<Types> : unknown,
+    Schema extends XAnyOf<infer Types extends XSchemaLike[]> ? StaticXAnyOf<Types> : unknown,
+    Schema extends XConst<infer Value extends unknown> ? StaticXConst<Value> : unknown,
+    Schema extends XEnum<infer Values extends unknown[]> ? StaticXEnum<Values> : unknown,
+    Schema extends XItems<infer Types extends XSchemaLike[] | XSchemaLike> ? StaticXItems<Types> : unknown,
+    Schema extends XOneOf<infer Types extends XSchemaLike[]> ? StaticXOneOf<Types> : unknown,
+    Schema extends XPatternProperties<infer Properties extends Record<PropertyKey, XSchemaLike>> ? StaticXPatternProperties<Properties> : unknown,
+    Schema extends XPrefixItems<infer Types extends XSchemaLike[]> ? StaticXPrefixItems<Types> : unknown,
+    Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchemaLike>> ? StaticXProperties<Properties> : unknown,
+    Schema extends XRequired<infer Keys extends string[]> ? StaticXRequired<Schema, Keys> : unknown,
+    Schema extends {
+        type: 'array';
+    } ? {} : unknown,
+    Schema extends {
+        type: 'bigint';
+    } ? bigint : unknown,
+    Schema extends {
+        type: 'boolean';
+    } ? boolean : unknown,
+    Schema extends {
+        type: 'integer';
+    } ? number : unknown,
+    Schema extends {
+        type: 'object';
+    } ? object : unknown,
+    Schema extends {
+        type: 'null';
+    } ? null : unknown,
+    Schema extends {
+        type: 'number';
+    } ? number : unknown,
+    Schema extends {
+        type: 'string';
+    } ? string : unknown,
+    Schema extends {
+        type: 'symbol';
+    } ? symbol : unknown,
+    Schema extends {
+        type: 'undefined';
+    } ? undefined : unknown
+]> = Result;
+type StaticXReduce<Schemas extends unknown[], Result extends unknown = unknown> = (Schemas extends [infer Left extends unknown, ...infer Right extends unknown[]] ? StaticXReduce<Right, Result & Left> : Result);
+type StaticXNonReadonlyTuple<Schemas extends readonly unknown[]> = (Schemas extends [infer Left, ...infer Right extends unknown[]] ? [StaticXNonReadonly<Left>, ...StaticXNonReadonlyTuple<Right>] : []);
+type StaticXNonReadonlyArray<Schema extends unknown, Result extends unknown[] = StaticXNonReadonly<Schema>[]> = Result;
+type StaticXNonReadonlyObject<Schema extends object, Result extends Record<PropertyKey, unknown> = {
+    -readonly [K in keyof Schema]: StaticXNonReadonly<Schema[K]>;
+}> = Result;
+type StaticXNonReadonly<Schema> = (Schema extends readonly [...infer Rest extends unknown[]] ? StaticXNonReadonlyTuple<Rest> : Schema extends readonly (infer U)[] ? StaticXNonReadonlyArray<U> : Schema extends object ? StaticXNonReadonlyObject<Schema> : Schema);
+type StaticXEvaluate<Schema extends unknown, Result extends unknown = Schema extends object ? {
+    [Key in keyof Schema]: Schema[Key];
+} : Schema> = Result;
+type StaticXSchema<Schema extends unknown, NonReadonly extends unknown = StaticXNonReadonly<Schema>, Keywords extends unknown[] = StaticXKeywords<NonReadonly>, Reduced extends unknown = StaticXReduce<Keywords>, Result extends unknown = StaticXEvaluate<Reduced>> = Result;
+/** Statically infers a JSON Schema or Standard Schema */
+export type XStatic<Schema extends XSchemaLike, Result extends unknown = (Schema extends XStandardSchemaV1<infer Validator extends XStandardValidatorV1> ? StaticXStandardSchemaV1<Validator> : StaticXSchema<Schema>)> = Result;
+export {};

package/build/schema/types/static.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/types/then.d.mts

@@ -0,0 +1,9 @@
+import { type XSchema, type XSchemaLike } from './schema.mjs';
+export interface XThen<Then extends XSchemaLike = XSchemaLike> {
+    then: Then;
+}
+/**
+ * Returns true if the schema contains a valid then property
+ * @specification Json Schema 7
+ */
+export declare function IsThen(schema: XSchema): schema is XThen;

package/build/schema/types/then.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchemaLike } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid then property
+ * @specification Json Schema 7
+ */
+export function IsThen(schema) {
+    return Guard.HasPropertyKey(schema, 'then')
+        && IsSchemaLike(schema.then);
+}

package/build/schema/types/type.d.mts

@@ -0,0 +1,9 @@
+import { type XSchema } from './schema.mjs';
+export interface XType<Type extends string | string[] = string | string[]> {
+    type: Type;
+}
+/**
+ * Returns true if the schema contains a valid type property
+ * @specification Json Schema 7
+ */
+export declare function IsType(schema: XSchema): schema is XType;

package/build/schema/types/type.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid type property
+ * @specification Json Schema 7
+ */
+export function IsType(schema) {
+    return Guard.HasPropertyKey(schema, 'type')
+        && (Guard.IsString(schema.type)
+            || (Guard.IsArray(schema.type)
+                && schema.type.every(value => Guard.IsString(value))));
+}

package/build/schema/types/unevaluatedItems.d.mts

@@ -0,0 +1,9 @@
+import { type XSchema, type XSchemaLike } from './schema.mjs';
+export interface XUnevaluatedItems<unevaluatedItems extends XSchemaLike = XSchemaLike> {
+    unevaluatedItems: XSchemaLike;
+}
+/**
+ * Returns true if the schema contains a valid unevaluatedItems property
+ * @specification Json Schema 2019-09
+ */
+export declare function IsUnevaluatedItems(schema: XSchema): schema is XUnevaluatedItems;

package/build/schema/types/unevaluatedItems.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchemaLike } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid unevaluatedItems property
+ * @specification Json Schema 2019-09
+ */
+export function IsUnevaluatedItems(schema) {
+    return Guard.HasPropertyKey(schema, 'unevaluatedItems')
+        && IsSchemaLike(schema.unevaluatedItems);
+}

package/build/schema/types/unevaluatedProperties.d.mts

@@ -0,0 +1,9 @@
+import { type XSchema, type XSchemaLike } from './schema.mjs';
+export interface XUnevaluatedProperties<UnevaluatedProperties extends XSchemaLike = XSchemaLike> {
+    unevaluatedProperties: UnevaluatedProperties;
+}
+/**
+ * Returns true if the schema contains a valid unevaluatedProperties property
+ * @specification Json Schema 2019-09
+ */
+export declare function IsUnevaluatedProperties(schema: XSchema): schema is XUnevaluatedProperties;

package/build/schema/types/unevaluatedProperties.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchemaLike } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid unevaluatedProperties property
+ * @specification Json Schema 2019-09
+ */
+export function IsUnevaluatedProperties(schema) {
+    return Guard.HasPropertyKey(schema, 'unevaluatedProperties')
+        && IsSchemaLike(schema.unevaluatedProperties);
+}

package/build/schema/types/uniqueItems.d.mts

@@ -0,0 +1,9 @@
+import { type XSchema } from './schema.mjs';
+export interface XUniqueItems<UniqueItems extends boolean = boolean> {
+    uniqueItems: UniqueItems;
+}
+/**
+ * Returns true if the schema contains a valid uniqueItems property
+ * @specification Json Schema 7
+ */
+export declare function IsUniqueItems(schema: XSchema): schema is XUniqueItems;

package/build/schema/types/uniqueItems.mjs

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid uniqueItems property
+ * @specification Json Schema 7
+ */
+export function IsUniqueItems(schema) {
+    return Guard.HasPropertyKey(schema, 'uniqueItems')
+        && Guard.IsBoolean(schema.uniqueItems);
+}

package/build/system/arguments/arguments.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Match arguments for overloaded functions that use the `...args: unknown[]` pattern. Arguments
+ * are parsed using argument length only.
+ */
+export declare function Match<Result>(args: unknown[], match: Record<number, (...args: unknown[]) => unknown>): Result;

package/build/system/arguments/arguments.mjs

@@ -0,0 +1,9 @@
+/**
+ * Match arguments for overloaded functions that use the `...args: unknown[]` pattern. Arguments
+ * are parsed using argument length only.
+ */
+export function Match(args, match) {
+    return (match[args.length]?.(...args) ?? (() => {
+        throw Error('Invalid Arguments');
+    })());
+}

package/build/system/arguments/index.d.mts

@@ -0,0 +1 @@
+export * as Arguments from './arguments.mjs';

package/build/system/arguments/index.mjs

@@ -0,0 +1 @@
+export * as Arguments from './arguments.mjs';

package/build/system/environment/can-evaluate.d.mts

@@ -0,0 +1,2 @@
+/** Returns true if the environment supports dynamic JavaScript evaluation */
+export declare function CanEvaluate(): boolean;

package/build/system/environment/can-evaluate.mjs

@@ -0,0 +1,26 @@
+import { Settings } from '../settings/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+let supported = undefined;
+// ------------------------------------------------------------------
+// TryEval
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - catch is environment dependent
+function TryEval() {
+    try {
+        new globalThis.Function('null')();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// deno-coverage-ignore-stop
+// ------------------------------------------------------------------
+// CanEvaluate
+// ------------------------------------------------------------------
+/** Returns true if the environment supports dynamic JavaScript evaluation */
+export function CanEvaluate() {
+    if (Guard.IsUndefined(supported))
+        supported = TryEval();
+    return supported && Settings.Get().useEval;
+}

package/build/system/environment/environment.d.mts

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

package/build/system/environment/environment.mjs

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

package/build/system/environment/index.d.mts

@@ -0,0 +1 @@
+export * as Environment from './environment.mjs';

package/build/system/environment/index.mjs

@@ -0,0 +1 @@
+export * as Environment from './environment.mjs';

package/build/system/hashing/hash.d.mts

@@ -0,0 +1,4 @@
+/** Generates a FNV1A-64 non cryptographic hash of the given value */
+export declare function HashCode(value: unknown): bigint;
+/** Generates a FNV1A-64 non cryptographic hash of the given value */
+export declare function Hash(value: unknown): string;

package/build/system/hashing/hash.mjs

@@ -0,0 +1,232 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../unreachable/index.mjs';
+import { Guard, GlobalsGuard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// InstanceKeys
+//
+// Retrieves all enumerable and non-enumerable own property keys 
+// and inherited prototype keys (excluding symbols and the 'constructor') 
+// from an object instance.
+//
+// This function is useful for differentiating between class instances 
+// based on their structural keys rather than relying on the 
+// constructor name. It provides a more reliable structural comparison 
+// by capturing both own and prototype properties.
+//
+// ------------------------------------------------------------------
+function InstanceKeys(value) {
+    const propertyKeys = new Set();
+    let current = value;
+    while (current && current !== Object.prototype) {
+        for (const key of Reflect.ownKeys(current)) {
+            if (key !== 'constructor' && typeof key !== 'symbol')
+                propertyKeys.add(key);
+        }
+        current = Object.getPrototypeOf(current);
+    }
+    return [...propertyKeys];
+}
+// ------------------------------------------------------------------
+// IsIEEE754
+//
+// TypeBox guards do not consider +/- Infinity or NaN as valid
+// numbers, but they are valid IEEE754 numbers. We use a special
+// guard to ensure these numbers are considered for hashing.
+//
+// ------------------------------------------------------------------
+function IsIEEE754(value) {
+    return typeof value === 'number';
+}
+// ------------------------------------------------------------------
+// ByteMarker
+// ------------------------------------------------------------------
+var ByteMarker;
+(function (ByteMarker) {
+    ByteMarker[ByteMarker["Array"] = 0] = "Array";
+    ByteMarker[ByteMarker["BigInt"] = 1] = "BigInt";
+    ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
+    ByteMarker[ByteMarker["Date"] = 3] = "Date";
+    ByteMarker[ByteMarker["Constructor"] = 4] = "Constructor";
+    ByteMarker[ByteMarker["Function"] = 5] = "Function";
+    ByteMarker[ByteMarker["Null"] = 6] = "Null";
+    ByteMarker[ByteMarker["Number"] = 7] = "Number";
+    ByteMarker[ByteMarker["Object"] = 8] = "Object";
+    ByteMarker[ByteMarker["RegExp"] = 9] = "RegExp";
+    ByteMarker[ByteMarker["String"] = 10] = "String";
+    ByteMarker[ByteMarker["Symbol"] = 11] = "Symbol";
+    ByteMarker[ByteMarker["TypeArray"] = 12] = "TypeArray";
+    ByteMarker[ByteMarker["Undefined"] = 13] = "Undefined";
+})(ByteMarker || (ByteMarker = {}));
+// ------------------------------------------------------------------
+// State
+// ------------------------------------------------------------------
+let Accumulator = BigInt('14695981039346656037');
+const [Prime, Size] = [BigInt('1099511628211'), BigInt('18446744073709551616' /* 2 ^ 64 */)];
+const Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i));
+const F64 = new Float64Array(1);
+const F64In = new DataView(F64.buffer);
+const F64Out = new Uint8Array(F64.buffer);
+// ------------------------------------------------------------------
+// Operation
+// ------------------------------------------------------------------
+function FNV1A64_OP(byte) {
+    Accumulator = Accumulator ^ Bytes[byte];
+    Accumulator = (Accumulator * Prime) % Size;
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+function FromArray(value) {
+    FNV1A64_OP(ByteMarker.Array);
+    for (const item of value) {
+        FromValue(item);
+    }
+}
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+function FromBigInt(value) {
+    FNV1A64_OP(ByteMarker.BigInt);
+    F64In.setBigInt64(0, value);
+    for (const byte of F64Out) {
+        FNV1A64_OP(byte);
+    }
+}
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+function FromBoolean(value) {
+    FNV1A64_OP(ByteMarker.Boolean);
+    FNV1A64_OP(value ? 1 : 0);
+}
+// ------------------------------------------------------------------
+// Constructor
+// ------------------------------------------------------------------
+function FromConstructor(value) {
+    FNV1A64_OP(ByteMarker.Constructor);
+    FromValue(value.toString());
+}
+// ------------------------------------------------------------------
+// Date
+// ------------------------------------------------------------------
+function FromDate(value) {
+    FNV1A64_OP(ByteMarker.Date);
+    FromValue(value.getTime());
+}
+// ------------------------------------------------------------------
+// Function
+// ------------------------------------------------------------------
+function FromFunction(value) {
+    FNV1A64_OP(ByteMarker.Function);
+    FromValue(value.toString());
+}
+// ------------------------------------------------------------------
+// Null
+// ------------------------------------------------------------------
+function FromNull(_value) {
+    FNV1A64_OP(ByteMarker.Null);
+}
+// ------------------------------------------------------------------
+// Number | IEEE754
+// ------------------------------------------------------------------
+function FromNumber(value) {
+    FNV1A64_OP(ByteMarker.Number);
+    F64In.setFloat64(0, value, true /* little-endian */);
+    for (const byte of F64Out) {
+        FNV1A64_OP(byte);
+    }
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+function FromObject(value) {
+    FNV1A64_OP(ByteMarker.Object);
+    for (const key of InstanceKeys(value).sort()) {
+        FromValue(key);
+        FromValue(value[key]);
+    }
+}
+// ------------------------------------------------------------------
+// RegExp
+// ------------------------------------------------------------------
+function FromRegExp(value) {
+    FNV1A64_OP(ByteMarker.RegExp);
+    FromString(value.toString());
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+const encoder = new TextEncoder();
+function FromString(value) {
+    FNV1A64_OP(ByteMarker.String);
+    for (const byte of encoder.encode(value)) {
+        FNV1A64_OP(byte);
+    }
+}
+// ------------------------------------------------------------------
+// Symbol
+// ------------------------------------------------------------------
+function FromSymbol(value) {
+    FNV1A64_OP(ByteMarker.Symbol);
+    FromValue(value.toString());
+}
+// ------------------------------------------------------------------
+// TypeArray
+// ------------------------------------------------------------------
+function FromTypeArray(value) {
+    FNV1A64_OP(ByteMarker.TypeArray);
+    const buffer = new Uint8Array(value.buffer);
+    for (let i = 0; i < buffer.length; i++) {
+        FNV1A64_OP(buffer[i]);
+    }
+}
+// ------------------------------------------------------------------
+// Undefined
+// ------------------------------------------------------------------
+function FromUndefined(_value) {
+    return FNV1A64_OP(ByteMarker.Undefined);
+}
+// ------------------------------------------------------------------
+// Hash
+//
+// deno-coverage-ignore-start - unreachable
+//
+// This function should all JavaScript values so we can't reach the
+// fall-through. We use Unreachable to assert that no values pass
+// through. We will need to handle these should they arise.
+//
+// ------------------------------------------------------------------
+function FromValue(value) {
+    return (GlobalsGuard.IsTypeArray(value) ? FromTypeArray(value) :
+        GlobalsGuard.IsDate(value) ? FromDate(value) :
+            GlobalsGuard.IsRegExp(value) ? FromRegExp(value) :
+                GlobalsGuard.IsBoolean(value) ? FromBoolean(value.valueOf()) :
+                    GlobalsGuard.IsString(value) ? FromString(value.valueOf()) :
+                        GlobalsGuard.IsNumber(value) ? FromNumber(value.valueOf()) :
+                            IsIEEE754(value) ? FromNumber(value) :
+                                Guard.IsArray(value) ? FromArray(value) :
+                                    Guard.IsBoolean(value) ? FromBoolean(value) :
+                                        Guard.IsBigInt(value) ? FromBigInt(value) :
+                                            Guard.IsConstructor(value) ? FromConstructor(value) :
+                                                Guard.IsNull(value) ? FromNull(value) :
+                                                    Guard.IsObject(value) ? FromObject(value) :
+                                                        Guard.IsString(value) ? FromString(value) :
+                                                            Guard.IsSymbol(value) ? FromSymbol(value) :
+                                                                Guard.IsUndefined(value) ? FromUndefined(value) :
+                                                                    Guard.IsFunction(value) ? FromFunction(value) :
+                                                                        Unreachable());
+}
+// deno-coverage-ignore-stop
+// ------------------------------------------------------------------
+// Hash
+// ------------------------------------------------------------------
+/** Generates a FNV1A-64 non cryptographic hash of the given value */
+export function HashCode(value) {
+    Accumulator = BigInt('14695981039346656037');
+    FromValue(value);
+    return Accumulator;
+}
+/** Generates a FNV1A-64 non cryptographic hash of the given value */
+export function Hash(value) {
+    return HashCode(value).toString(16).padStart(16, '0');
+}

package/build/system/hashing/index.d.mts

@@ -0,0 +1 @@
+export * as Hashing from './hash.mjs';

package/build/system/hashing/index.mjs

@@ -0,0 +1 @@
+export * as Hashing from './hash.mjs';

package/build/system/index.d.mts

@@ -0,0 +1,4 @@
+export * from './system.mjs';
+export * as System from './system.mjs';
+import * as System from './system.mjs';
+export default System;

package/build/system/index.mjs

@@ -0,0 +1,4 @@
+export * from './system.mjs';
+export * as System from './system.mjs';
+import * as System from './system.mjs';
+export default System;