@ariestools/sdk 7.0.3

package/dist/_pkg/typeof/neutral/index.mjs

@@ -0,0 +1,255 @@
+// src/typeOf.ts
+var typeOf = (item) => {
+  return Array.isArray(item) ? "array" : typeof item;
+};
+
+// src/ifDefined.ts
+var ifDefined = (value, func) => {
+  switch (typeOf(value)) {
+    case "undefined":
+    case "null": {
+      break;
+    }
+    default: {
+      func(value);
+      return value;
+    }
+  }
+};
+
+// src/ifTypeOf.ts
+var ifTypeOf = (typeName, value, trueFunc, isFunc) => {
+  switch (typeOf(value)) {
+    case typeName: {
+      return !isFunc || isFunc(value) ? trueFunc(value) : void 0;
+    }
+  }
+};
+
+// src/is.ts
+function isUndefined(value) {
+  return value === void 0;
+}
+function isDefined(value) {
+  return !isUndefined(value);
+}
+function isNull(value) {
+  return value === null;
+}
+function isDefinedNotNull(value) {
+  return !isUndefined(value) && !isNull(value);
+}
+function isUndefinedOrNull(value) {
+  return isUndefined(value) || isNull(value);
+}
+function isBigInt(value) {
+  return typeof value === "bigint";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isSymbol(value) {
+  return typeof value === "symbol";
+}
+function isEmptyObject(value) {
+  return isObject(value) && Object.keys(value).length === 0;
+}
+function isEmptyString(value) {
+  return isString(value) && value.length === 0;
+}
+function isEmptyArray(value) {
+  return isArray(value) && value.length === 0;
+}
+function isPopulatedArray(value) {
+  return isArray(value) && value.length > 0;
+}
+function isEmpty(value) {
+  return isEmptyString(value) || isEmptyArray(value) || isEmptyObject(value);
+}
+function isFalsy(value) {
+  return !value;
+}
+function isTruthy(value) {
+  return !!value;
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isDateString(value) {
+  return isString(value) && !Number.isNaN(Date.parse(value));
+}
+function isDate(value) {
+  return value instanceof Date;
+}
+function isRegExp(value) {
+  return value instanceof RegExp;
+}
+function isError(value) {
+  return value instanceof Error;
+}
+function isPromise(value) {
+  return value instanceof Promise;
+}
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+function isMap(value) {
+  return value instanceof Map;
+}
+function isArrayBufferView(value) {
+  return ArrayBuffer.isView(value);
+}
+function isSet(value) {
+  return value instanceof Set;
+}
+function isWeakMap(value) {
+  return value instanceof WeakMap;
+}
+function isWeakSet(value) {
+  return value instanceof WeakSet;
+}
+function isDataView(value) {
+  return value instanceof DataView;
+}
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFile(value) {
+  return typeof File !== "undefined" && value instanceof File;
+}
+
+// src/isType.ts
+var isType = (value, expectedType) => {
+  const typeofValue = typeof value;
+  switch (expectedType) {
+    case "array": {
+      return Array.isArray(value);
+    }
+    case "null": {
+      return value === null;
+    }
+    case "undefined": {
+      return value === void 0;
+    }
+    case "object": {
+      if (value === null) {
+        return false;
+      }
+      return typeofValue === "object" && !Array.isArray(value);
+    }
+    default: {
+      return typeofValue === expectedType;
+    }
+  }
+};
+
+// src/Typed.ts
+var isTypedKey = (value) => {
+  switch (typeof value) {
+    case "string":
+    case "bigint":
+    case "number":
+    case "symbol": {
+      return true;
+    }
+    default: {
+      return false;
+    }
+  }
+};
+var isTypedValue = (value) => {
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean": {
+      return true;
+    }
+    default: {
+      return value === null || isTypedObject(value) || isTypedArray(value);
+    }
+  }
+};
+var isTypedArray = (value) => {
+  return Array.isArray(value) && value.every((item) => isTypedValue(item));
+};
+var isValidTypedFieldPair = (pair) => {
+  const [key, value] = pair;
+  return isTypedKey(key) && isTypedValue(value);
+};
+var isTypedObject = (value) => {
+  return isType(value, "object") && Object.entries(value).every((item) => isValidTypedFieldPair(item));
+};
+
+// src/validateType.ts
+var validateType = (typeName, value, optional = false) => {
+  switch (typeOf(value)) {
+    case typeName: {
+      return [value, []];
+    }
+    default: {
+      if (optional && typeOf(value) === "undefined") {
+        return [value, []];
+      }
+      return [void 0, [new Error(`value type is not '${typeName}:${typeof value}'`)]];
+    }
+  }
+};
+export {
+  ifDefined,
+  ifTypeOf,
+  isArray,
+  isArrayBufferView,
+  isBigInt,
+  isBlob,
+  isBoolean,
+  isDataView,
+  isDate,
+  isDateString,
+  isDefined,
+  isDefinedNotNull,
+  isEmpty,
+  isEmptyArray,
+  isEmptyObject,
+  isEmptyString,
+  isError,
+  isFalsy,
+  isFile,
+  isFunction,
+  isMap,
+  isNull,
+  isNumber,
+  isObject,
+  isPopulatedArray,
+  isPromise,
+  isPromiseLike,
+  isRegExp,
+  isSet,
+  isString,
+  isSymbol,
+  isTruthy,
+  isType,
+  isTypedArray,
+  isTypedKey,
+  isTypedObject,
+  isTypedValue,
+  isUndefined,
+  isUndefinedOrNull,
+  isValidTypedFieldPair,
+  isWeakMap,
+  isWeakSet,
+  typeOf,
+  validateType
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/typeof/neutral/is.d.ts

@@ -0,0 +1,116 @@
+/** A function type that accepts any arguments and returns unknown. */
+export type AnyFunction = (...args: unknown[]) => unknown;
+/** A union of valid object key types. */
+export type RecordKey = string | number | symbol;
+/** Type guard that checks whether a value is undefined. */
+export declare function isUndefined(value: unknown): value is undefined;
+export declare function isUndefined<T>(value: T): value is Extract<T, undefined>;
+/** Type guard that checks whether a value is not undefined. */
+export declare function isDefined<T>(value: T): value is Exclude<T, undefined>;
+/** Type guard that checks whether a value is null. */
+export declare function isNull(value: unknown): value is null;
+export declare function isNull<T>(value: T): value is Extract<T, null>;
+/** Type guard that checks whether a value is neither undefined nor null. */
+export declare function isDefinedNotNull<T>(value: T): value is Exclude<T, undefined | null>;
+/** Type guard that checks whether a value is undefined or null. */
+export declare function isUndefinedOrNull(value: unknown): value is undefined | null;
+export declare function isUndefinedOrNull<T>(value: T): value is Extract<T, undefined | null>;
+/** Type guard that checks whether a value is a bigint. */
+export declare function isBigInt(value: unknown): value is bigint;
+export declare function isBigInt<T extends bigint>(value: T): value is Extract<T, bigint>;
+/** Type guard that checks whether a value is a string. */
+export declare function isString(value: unknown): value is string;
+export declare function isString<T extends string>(value: T): value is Extract<T, string>;
+/** Type guard that checks whether a value is a number. */
+export declare function isNumber(value: unknown): value is number;
+export declare function isNumber<T extends number>(value: T): value is Extract<T, number>;
+/** Type guard that checks whether a value is a plain object (not null and not an array). */
+export declare function isObject(value: unknown): value is object;
+export declare function isObject<T extends object>(value: T): value is Extract<T, object>;
+/** Type guard that checks whether a value is an array. */
+export declare function isArray(value: unknown): value is readonly unknown[];
+export declare function isArray<T>(value: T): value is Extract<T, readonly unknown[]>;
+/** Type guard that checks whether a value is a function. */
+export declare function isFunction(value: unknown): value is AnyFunction;
+export declare function isFunction<T extends AnyFunction>(value: T): value is Extract<T, AnyFunction>;
+/** Type guard that checks whether a value is a symbol. */
+export declare function isSymbol(value: unknown): value is symbol;
+export declare function isSymbol<T extends symbol>(value: T): value is Extract<T, symbol>;
+/** Type guard that checks whether a value is an object with no own keys. */
+export declare function isEmptyObject(value: unknown): value is {};
+export declare function isEmptyObject<K extends RecordKey, V, T extends Record<K, V>>(value: T): value is Extract<T, Record<K, never>>;
+/** Type guard that checks whether a value is an empty string. */
+export declare function isEmptyString(value: unknown): value is '';
+export declare function isEmptyString<T extends string>(value: T): value is Extract<T, ''>;
+/** Type guard that checks whether a value is an empty array. */
+export declare function isEmptyArray(value: unknown): value is [];
+export declare function isEmptyArray<T extends unknown[]>(value: T): value is Extract<T, unknown[]>;
+/** Type guard that checks whether a value is a non-empty array. */
+export declare function isPopulatedArray(value: unknown): value is readonly unknown[];
+export declare function isPopulatedArray<T extends unknown[]>(value: T): value is Extract<T, readonly unknown[]>;
+/** Type guard that checks whether a value is empty (empty string, empty array, or empty object). */
+export declare function isEmpty<T>(value: unknown): value is T;
+export declare function isEmpty<K extends RecordKey, V, T extends Record<K, V>>(value: T): value is Extract<T, Record<K, never>>;
+export declare function isEmpty<T extends unknown[]>(value: T): value is Extract<T, never[]>;
+/** Type guard that checks whether a value is falsy (0, null, undefined, false, '', or 0n). */
+export declare function isFalsy<T>(value: T): value is Extract<T, 0 | null | undefined | false | '' | 0n>;
+export declare function isFalsy<T extends boolean>(value: T): value is Extract<T, false>;
+export declare function isFalsy<T extends number>(value: T): value is Extract<T, 0>;
+export declare function isFalsy<T extends bigint>(value: T): value is Extract<T, 0n>;
+export declare function isFalsy<T extends null>(value: T): value is Extract<T, null>;
+export declare function isFalsy<T extends undefined>(value: T): value is Extract<T, undefined>;
+export declare function isFalsy<T extends string>(value: T): value is Extract<T, ''>;
+/** Type guard that checks whether a value is truthy (not 0, null, undefined, false, '', or 0n). */
+export declare function isTruthy<T>(value: T): value is Exclude<T, 0 | null | undefined | false | '' | 0n>;
+export declare function isTruthy<T extends boolean>(value: T): value is Extract<T, true>;
+export declare function isTruthy<T extends number>(value: T): value is Extract<T, number>;
+export declare function isTruthy<T extends bigint>(value: T): value is Extract<T, bigint>;
+export declare function isTruthy<T extends null>(value: T): value is Extract<T, null>;
+export declare function isTruthy<T extends undefined>(value: T): value is Extract<T, undefined>;
+export declare function isTruthy<T extends string>(value: T): value is Extract<T, string>;
+/** Type guard that checks whether a value is a boolean. */
+export declare function isBoolean(value: unknown): value is boolean;
+export declare function isBoolean<T extends boolean>(value: T): value is Extract<T, boolean>;
+/** Type guard that checks whether a value is a string that can be parsed as a valid date. */
+export declare function isDateString(value: unknown): value is string;
+export declare function isDateString<T>(value: T): value is Extract<T, string>;
+/** Type guard that checks whether a value is a Date instance. */
+export declare function isDate(value: unknown): value is Date;
+export declare function isDate<T>(value: T): value is Extract<T, Date>;
+/** Type guard that checks whether a value is a RegExp instance. */
+export declare function isRegExp(value: unknown): value is RegExp;
+export declare function isRegExp<T extends RegExp>(value: T): value is Extract<T, RegExp>;
+/** Type guard that checks whether a value is an Error instance. */
+export declare function isError(value: unknown): value is Error;
+export declare function isError<T>(value: T): value is Extract<T, Error>;
+/** Type guard that checks whether a value is a Promise instance. */
+export declare function isPromise(value: unknown): value is Promise<unknown>;
+export declare function isPromise<T>(value: T): value is Extract<T, Promise<unknown>>;
+/** Type guard that checks whether a value is promise-like (has a `then` method). */
+export declare function isPromiseLike(value: unknown): value is Promise<unknown>;
+export declare function isPromiseLike<T>(value: T): value is Extract<T, Promise<unknown>>;
+/** Type guard that checks whether a value is a Map instance. */
+export declare function isMap(value: unknown): value is Map<unknown, unknown>;
+export declare function isMap<K, V, T extends Map<K, V>>(value: T): value is Extract<T, Map<K, V>>;
+/** Type guard that checks whether a value is an ArrayBufferView (e.g., TypedArray or DataView). */
+export declare function isArrayBufferView(value: unknown): value is ArrayBufferView;
+export declare function isArrayBufferView<T extends ArrayBufferView>(value: T): value is Extract<T, ArrayBufferView>;
+/** Type guard that checks whether a value is a Set instance. */
+export declare function isSet(value: unknown): value is Set<unknown>;
+export declare function isSet<T extends Set<unknown>>(value: T): value is Extract<T, Set<unknown>>;
+/** Type guard that checks whether a value is a WeakMap instance. */
+export declare function isWeakMap(value: unknown): value is WeakMap<WeakKey, unknown>;
+export declare function isWeakMap<K extends WeakKey, V, T extends WeakMap<K, V>>(value: T): value is Extract<T, WeakMap<K, V>>;
+/** Type guard that checks whether a value is a WeakSet instance. */
+export declare function isWeakSet(value: unknown): value is WeakSet<WeakKey>;
+export declare function isWeakSet<K extends WeakKey, T extends WeakSet<K>>(value: T): value is Extract<T, WeakSet<K>>;
+/** Type guard that checks whether a value is a DataView instance. */
+export declare function isDataView(value: unknown): value is DataView;
+export declare function isDataView<T>(value: T): value is Extract<T, DataView>;
+/** Type guard that checks whether a value is a Blob instance. */
+export declare function isBlob(value: unknown): value is Blob;
+export declare function isBlob<T extends Blob>(value: T): value is Extract<T, Blob>;
+/** Type guard that checks whether a value is a File instance. */
+export declare function isFile(value: unknown): value is File;
+export declare function isFile<T extends File>(value: T): value is Extract<T, File>;
+//# sourceMappingURL=is.d.ts.map

package/dist/_pkg/typeof/neutral/isType.d.ts

@@ -0,0 +1,9 @@
+import type { FieldType } from './ObjectTypeShape.ts';
+/**
+ * Checks whether a value matches the expected field type, with correct handling for arrays and nulls.
+ * @param value - The value to check.
+ * @param expectedType - The expected type string.
+ * @returns True if the value matches the expected type.
+ */
+export declare const isType: (value: unknown, expectedType: FieldType) => boolean;
+//# sourceMappingURL=isType.d.ts.map

package/dist/_pkg/typeof/neutral/model.d.ts

@@ -0,0 +1,7 @@
+export type * from './Brand.ts';
+export type * from './IdentityFunction.ts';
+export type { AnyFunction, RecordKey, } from './is.ts';
+export type * from './ObjectTypeShape.ts';
+export type { TypedArray, TypedKey, TypedObject, TypedValue, } from './Typed.ts';
+export type * from './TypeOfTypes.ts';
+//# sourceMappingURL=model.d.ts.map

package/dist/_pkg/typeof/neutral/model.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=model.mjs.map

package/dist/_pkg/typeof/neutral/typeOf.d.ts

@@ -0,0 +1,8 @@
+import type { TypeOfTypes } from './TypeOfTypes.ts';
+/**
+ * Extended typeof that distinguishes arrays from objects (unlike native `typeof`).
+ * @param item - The value to check.
+ * @returns The type of the item as a TypeOfTypes string.
+ */
+export declare const typeOf: <T>(item: T) => TypeOfTypes;
+//# sourceMappingURL=typeOf.d.ts.map

package/dist/_pkg/typeof/neutral/validateType.d.ts

@@ -0,0 +1,10 @@
+import type { TypeOfTypes } from './TypeOfTypes.ts';
+/**
+ * Validates that a value matches the expected type, returning the value and any errors.
+ * @param typeName - The expected type name.
+ * @param value - The value to validate.
+ * @param optional - If true, undefined values are accepted without error.
+ * @returns A tuple of [value or undefined, array of errors].
+ */
+export declare const validateType: <T>(typeName: TypeOfTypes, value: T, optional?: boolean) => [T | undefined, Error[]];
+//# sourceMappingURL=validateType.d.ts.map

package/dist/_pkg/url/browser/index-browser.d.ts

@@ -0,0 +1,12 @@
+/** Browser-specific URL class, aliased from the global `URL`. */
+declare const BrowserUrl: {
+    new (url: string | URL, base?: string | URL): URL;
+    prototype: URL;
+    canParse(url: string | URL, base?: string | URL): boolean;
+    createObjectURL(obj: Blob | MediaSource): string;
+    parse(url: string | URL, base?: string | URL): URL | null;
+    revokeObjectURL(url: string): void;
+};
+export { BrowserUrl as URL };
+export * from './lib/index.ts';
+//# sourceMappingURL=index-browser.d.ts.map

package/dist/_pkg/url/browser/index-browser.mjs

@@ -0,0 +1,12 @@
+// src/lib/isLocalhost.ts
+var isLocalhost = (hostname) => {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost");
+};
+
+// src/index-browser.ts
+var BrowserUrl = URL;
+export {
+  BrowserUrl as URL,
+  isLocalhost
+};
+//# sourceMappingURL=index-browser.mjs.map

package/dist/_pkg/url/browser/index-neutral.d.ts

@@ -0,0 +1,12 @@
+/** Platform-neutral URL class, aliased from the global `URL`. */
+declare const NeutralUrl: {
+    new (url: string | URL, base?: string | URL): URL;
+    prototype: URL;
+    canParse(url: string | URL, base?: string | URL): boolean;
+    createObjectURL(obj: Blob | MediaSource): string;
+    parse(url: string | URL, base?: string | URL): URL | null;
+    revokeObjectURL(url: string): void;
+};
+export { NeutralUrl as URL };
+export * from './lib/index.ts';
+//# sourceMappingURL=index-neutral.d.ts.map

package/dist/_pkg/url/browser/index-node.d.ts

@@ -0,0 +1,13 @@
+import { URL } from 'node:url';
+/** Node.js-specific URL class, imported from the `node:url` module. */
+declare const NodeUrl: {
+    new (url: string | URL, base?: string | URL): URL;
+    prototype: URL;
+    canParse(input: string | URL, base?: string | URL): boolean;
+    createObjectURL(blob: import("node:buffer").Blob): string;
+    parse(input: string | URL, base?: string | URL): URL | null;
+    revokeObjectURL(id: string): void;
+};
+export { NodeUrl as URL };
+export * from './lib/index.ts';
+//# sourceMappingURL=index-node.d.ts.map

package/dist/_pkg/url/browser/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './isLocalhost.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/url/browser/lib/isLocalhost.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks whether a hostname refers to the local machine (localhost, 127.0.0.1, ::1, or *.localhost).
+ * @param hostname - The hostname to check
+ * @returns `true` if the hostname is a localhost address
+ */
+export declare const isLocalhost: (hostname: string) => boolean;
+//# sourceMappingURL=isLocalhost.d.ts.map

package/dist/_pkg/url/neutral/index-browser.d.ts

@@ -0,0 +1,12 @@
+/** Browser-specific URL class, aliased from the global `URL`. */
+declare const BrowserUrl: {
+    new (url: string | URL, base?: string | URL): URL;
+    prototype: URL;
+    canParse(url: string | URL, base?: string | URL): boolean;
+    createObjectURL(obj: Blob | MediaSource): string;
+    parse(url: string | URL, base?: string | URL): URL | null;
+    revokeObjectURL(url: string): void;
+};
+export { BrowserUrl as URL };
+export * from './lib/index.ts';
+//# sourceMappingURL=index-browser.d.ts.map

package/dist/_pkg/url/neutral/index-neutral.d.ts

@@ -0,0 +1,12 @@
+/** Platform-neutral URL class, aliased from the global `URL`. */
+declare const NeutralUrl: {
+    new (url: string | URL, base?: string | URL): URL;
+    prototype: URL;
+    canParse(url: string | URL, base?: string | URL): boolean;
+    createObjectURL(obj: Blob | MediaSource): string;
+    parse(url: string | URL, base?: string | URL): URL | null;
+    revokeObjectURL(url: string): void;
+};
+export { NeutralUrl as URL };
+export * from './lib/index.ts';
+//# sourceMappingURL=index-neutral.d.ts.map

package/dist/_pkg/url/neutral/index-neutral.mjs

@@ -0,0 +1,12 @@
+// src/lib/isLocalhost.ts
+var isLocalhost = (hostname) => {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost");
+};
+
+// src/index-neutral.ts
+var NeutralUrl = URL;
+export {
+  NeutralUrl as URL,
+  isLocalhost
+};
+//# sourceMappingURL=index-neutral.mjs.map

package/dist/_pkg/url/neutral/index-node.d.ts

@@ -0,0 +1,13 @@
+import { URL } from 'node:url';
+/** Node.js-specific URL class, imported from the `node:url` module. */
+declare const NodeUrl: {
+    new (url: string | URL, base?: string | URL): URL;
+    prototype: URL;
+    canParse(input: string | URL, base?: string | URL): boolean;
+    createObjectURL(blob: import("node:buffer").Blob): string;
+    parse(input: string | URL, base?: string | URL): URL | null;
+    revokeObjectURL(id: string): void;
+};
+export { NodeUrl as URL };
+export * from './lib/index.ts';
+//# sourceMappingURL=index-node.d.ts.map

package/dist/_pkg/url/neutral/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './isLocalhost.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/url/neutral/lib/isLocalhost.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks whether a hostname refers to the local machine (localhost, 127.0.0.1, ::1, or *.localhost).
+ * @param hostname - The hostname to check
+ * @returns `true` if the hostname is a localhost address
+ */
+export declare const isLocalhost: (hostname: string) => boolean;
+//# sourceMappingURL=isLocalhost.d.ts.map

package/dist/_pkg/url/node/index-browser.d.ts

@@ -0,0 +1,12 @@
+/** Browser-specific URL class, aliased from the global `URL`. */
+declare const BrowserUrl: {
+    new (url: string | URL, base?: string | URL): URL;
+    prototype: URL;
+    canParse(url: string | URL, base?: string | URL): boolean;
+    createObjectURL(obj: Blob | MediaSource): string;
+    parse(url: string | URL, base?: string | URL): URL | null;
+    revokeObjectURL(url: string): void;
+};
+export { BrowserUrl as URL };
+export * from './lib/index.ts';
+//# sourceMappingURL=index-browser.d.ts.map

package/dist/_pkg/url/node/index-neutral.d.ts

@@ -0,0 +1,12 @@
+/** Platform-neutral URL class, aliased from the global `URL`. */
+declare const NeutralUrl: {
+    new (url: string | URL, base?: string | URL): URL;
+    prototype: URL;
+    canParse(url: string | URL, base?: string | URL): boolean;
+    createObjectURL(obj: Blob | MediaSource): string;
+    parse(url: string | URL, base?: string | URL): URL | null;
+    revokeObjectURL(url: string): void;
+};
+export { NeutralUrl as URL };
+export * from './lib/index.ts';
+//# sourceMappingURL=index-neutral.d.ts.map

package/dist/_pkg/url/node/index-node.d.ts

@@ -0,0 +1,13 @@
+import { URL } from 'node:url';
+/** Node.js-specific URL class, imported from the `node:url` module. */
+declare const NodeUrl: {
+    new (url: string | URL, base?: string | URL): URL;
+    prototype: URL;
+    canParse(input: string | URL, base?: string | URL): boolean;
+    createObjectURL(blob: import("node:buffer").Blob): string;
+    parse(input: string | URL, base?: string | URL): URL | null;
+    revokeObjectURL(id: string): void;
+};
+export { NodeUrl as URL };
+export * from './lib/index.ts';
+//# sourceMappingURL=index-node.d.ts.map

package/dist/_pkg/url/node/index-node.mjs

@@ -0,0 +1,15 @@
+// src/index-node.ts
+import { URL } from "node:url";
+
+// src/lib/isLocalhost.ts
+var isLocalhost = (hostname) => {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost");
+};
+
+// src/index-node.ts
+var NodeUrl = URL;
+export {
+  NodeUrl as URL,
+  isLocalhost
+};
+//# sourceMappingURL=index-node.mjs.map

package/dist/_pkg/url/node/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './isLocalhost.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/url/node/lib/isLocalhost.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks whether a hostname refers to the local machine (localhost, 127.0.0.1, ::1, or *.localhost).
+ * @param hostname - The hostname to check
+ * @returns `true` if the hostname is a localhost address
+ */
+export declare const isLocalhost: (hostname: string) => boolean;
+//# sourceMappingURL=isLocalhost.d.ts.map

package/dist/_pkg/zod/neutral/Config.d.ts

@@ -0,0 +1,8 @@
+import type { AssertConfig } from '../../error/neutral/index.ts';
+/** Configuration object for zod factory functions, providing a name for error messages. */
+export interface ZodFactoryConfigObject {
+    name: string;
+}
+/** Configuration for zod factory assertion behavior, either an AssertConfig or a named config object. */
+export type ZodFactoryConfig = AssertConfig | ZodFactoryConfigObject;
+//# sourceMappingURL=Config.d.ts.map

package/dist/_pkg/zod/neutral/index.d.ts

@@ -0,0 +1,8 @@
+export * from './Config.ts';
+export * from './zodAllFactory.ts';
+export * from './zodAsAsyncFactory.ts';
+export * from './zodAsFactory.ts';
+export * from './zodIsFactory.ts';
+export * from './zodToAsyncFactory.ts';
+export * from './zodToFactory.ts';
+//# sourceMappingURL=index.d.ts.map