@spudlabs/guardis 0.4.0

package/esm/src/guard.js

@@ -0,0 +1,631 @@
+/**
+ * guard.ts
+ * @module
+ */
+import { createContext, createStrictContext } from "./context.js";
+import { hasContext, hasName } from "./introspect.js";
+import { doesNotHaveProperty, formatErrorMessage, hasOptionalProperty, hasProperty, includes, keyOf, tupleHas, unionOf, } from "./utilities.js";
+/**
+ * Creates a helpers object for use in type guard parsers.
+ * When ctx is provided, has/hasOptional pass context for path tracking.
+ * When ctx is undefined, they use raw functions (for boolean type guard calls).
+ */
+function createHelpers(ctx) {
+    return {
+        has: (t, k, guard, errorMessage) => hasProperty(t, k, guard, ctx?.pushPath(k), ctx ? errorMessage : undefined),
+        hasNot: (t, k, errorMessage) => doesNotHaveProperty(t, k, ctx?.pushPath(k), ctx ? errorMessage : undefined),
+        hasOptional: (t, k, guard, errorMessage) => hasOptionalProperty(t, k, guard, ctx?.pushPath(k), ctx ? errorMessage : undefined),
+        tupleHas,
+        includes,
+        keyOf: (k, t, errorMessage) => keyOf(k, t, ctx, ctx ? errorMessage : undefined),
+        fail: (message) => {
+            if (ctx)
+                ctx.addIssue(message);
+            return null;
+        },
+        _ctx: ctx,
+    };
+}
+/** Default helpers for boolean type guard calls (no validation context) */
+const defaultHelpers = createHelpers();
+/**
+ * Checks if a value is a TypeGuardShape object (plain object, not a function).
+ * Uses raw checks instead of isObject/isFunction to avoid temporal dead zone
+ * issues — this function is called during createTypeGuard's implementation,
+ * which runs before isObject and isFunction are initialized.
+ */
+function isTypeGuardShape(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) &&
+        typeof value !== "function";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Adds issues from a guard result to the context if not already tracked. */
+function propagateIssues(issues, key, ctx) {
+    for (const issue of issues) {
+        const alreadyTracked = ctx.issues.some((i) => i.message === issue.message &&
+            JSON.stringify(i.path) === JSON.stringify(issue.path));
+        if (!alreadyTracked) {
+            ctx.issues.push({ message: issue.message, path: issue.path ?? [key] });
+        }
+    }
+}
+/**
+ * Validates a single shape field against its guard.
+ * When ctx is provided, issues are pushed to the shared context.
+ * When ctx is absent, issues are collected into localIssues.
+ */
+function validateField(obj, key, guard, ctx, localIssues, result) {
+    const childCtx = ctx?.pushPath(key);
+    // Nested shape — recurse
+    if (isTypeGuardShape(guard)) {
+        const r = validateShape(obj[key], guard, childCtx);
+        if ("value" in r) {
+            result[key] = r.value;
+        }
+        else if (!childCtx) {
+            localIssues.push(...r.issues);
+        }
+        return;
+    }
+    if (typeof guard !== "function")
+        return;
+    // Context-aware guard (TypeGuard with _.context)
+    if (hasContext(guard)) {
+        const guardCtx = childCtx ?? createContext([key]);
+        const r = guard._.context(obj[key], guardCtx);
+        if ("value" in r) {
+            result[key] = r.value;
+        }
+        else if (childCtx) {
+            propagateIssues(r.issues, key, ctx);
+        }
+        else {
+            localIssues.push(...r.issues);
+        }
+        return;
+    }
+    // Plain boolean guard
+    if (guard(obj[key])) {
+        result[key] = obj[key];
+        return;
+    }
+    const message = `Validation failed for property "${String(key)}"`;
+    if (childCtx) {
+        childCtx.addIssue(message);
+    }
+    else {
+        localIssues.push({ message, path: [key] });
+    }
+}
+/**
+ * Recursively validates a value against a TypeGuardShape.
+ * When ctx is provided, issues are pushed to the shared context for path tracking.
+ * When ctx is absent, issues are collected locally and returned.
+ */
+function validateShape(value, shape, ctx) {
+    if (!isRecord(value)) {
+        const message = "Expected an object";
+        if (!ctx)
+            return { issues: [{ message }] };
+        ctx.addIssue(message);
+        return { issues: ctx.issues };
+    }
+    const result = {};
+    const localIssues = [];
+    for (const key of Object.keys(shape)) {
+        validateField(value, key, shape[key], ctx, localIssues, result);
+    }
+    const issues = ctx ? ctx.issues : localIssues;
+    return issues.length > 0 ? { issues } : { value: result };
+}
+/**
+ * Creates a type guard that strictly checks the type, throwing
+ * a TypeError if it fails. Uses strict context for detailed error messages
+ * with path information on nested validations.
+ * @param parser The parser function to use for validation
+ * @param name Optional name of the type guard for error messages
+ * @returns A strict type guard that throws on failure
+ */
+const createStrictTypeGuard = (parser, name) => {
+    return (value, errorMsg) => {
+        const ctx = createStrictContext();
+        const helpers = createHelpers(ctx);
+        const result = parser(value, helpers);
+        if (result === null) {
+            throw new TypeError(errorMsg ?? formatErrorMessage(value, name));
+        }
+        return true;
+    };
+};
+/**
+ * Creates a callback to construct a union type guard from two existing type guards.
+ *
+ * @template T1 - The type checked by the first type guard.
+ * @template T2 - The type checked by the second type guard.
+ *
+ * @param guard - A type guard function that checks if a value is of type `T1`.
+ * @returns A function that takes a second type guard `guardTwo` and returns a new
+ * type guard that checks if a value is of type `T1 | T2`.
+ *
+ * @example
+ * ```typescript
+ * const isString = (value: unknown): value is string => typeof value === 'string';
+ * const isNumber = (value: unknown): value is number => typeof value === 'number';
+ *
+ * const isStringOrNumber = createOrTypeGuard(isString)(isNumber);
+ *
+ * console.log(isStringOrNumber("hello")); // true
+ * console.log(isStringOrNumber(42)); // true
+ * console.log(isStringOrNumber(false)); // false
+ * ```
+ */
+const createOrTypeGuard = (guard) => (guardTwo) => {
+    // Create a union of the names of the two guards for better error messages, if available.
+    const name = hasName(guard) && hasName(guardTwo)
+        ? `${guard._.name} | ${guardTwo._.name}`
+        : undefined;
+    const parser = (v) => {
+        if (guard(v) || guardTwo(v))
+            return v === null ? true : v;
+        return null;
+    };
+    return name ? createTypeGuard(name, parser) : createTypeGuard(parser);
+};
+/**
+ * Creates a notEmpty variant of a type guard that rejects empty values
+ * (null, undefined, empty string, empty array, empty object).
+ */
+const createNotEmptyTypeGuard = (guard) => {
+    const notEmpty = (value) => !isEmpty(value) && guard(value);
+    const name = hasName(guard) ? `non-empty ${guard._.name}` : undefined;
+    const notEmptyParser = (value) => notEmpty(value) && guard(value) ? value : null;
+    const context = (value, ctx) => {
+        if (notEmpty(value))
+            return { value };
+        const message = formatErrorMessage(value, name);
+        const path = ctx?.path.length ? [...ctx.path] : undefined;
+        return { issues: [path ? { message, path } : { message }] };
+    };
+    notEmpty._ = {
+        name,
+        parser: notEmptyParser,
+        context,
+    };
+    notEmpty.strict = createStrictTypeGuard(notEmptyParser, name);
+    notEmpty.assert = notEmpty.strict;
+    notEmpty.validate = (value) => context(value, createContext());
+    const notEmptyOptional = (value) => guard(value) ? notEmpty(value) : isUndefined(value);
+    const optionalName = name ? `${name} | undefined` : undefined;
+    const optionalParser = (v) => notEmptyOptional(v) ? v : null;
+    notEmptyOptional.strict = createStrictTypeGuard(optionalParser, optionalName);
+    notEmptyOptional.assert = notEmptyOptional.strict;
+    notEmptyOptional.validate = (value) => {
+        if (isUndefined(value))
+            return { value: value };
+        return context(value, createContext());
+    };
+    notEmptyOptional.or = createOrTypeGuard(notEmptyOptional);
+    notEmpty.optional = notEmptyOptional;
+    notEmpty.or = createOrTypeGuard(notEmpty);
+    return notEmpty;
+};
+export function createTypeGuard(...args) {
+    const parserOrShape = args.length === 1 ? args[0] : args[1];
+    const name = args.length === 2 ? args[0] : undefined;
+    // Convert shape to parser, then continue with normal guard creation
+    const parser = isTypeGuardShape(parserOrShape)
+        ? (val, helpers) => {
+            const ctx = helpers._ctx;
+            const result = validateShape(val, parserOrShape, ctx);
+            return "value" in result ? result.value : null;
+        }
+        : parserOrShape;
+    /**
+     * Internal validation method that accepts a context for path tracking.
+     * This is used by nested validations to propagate paths.
+     */
+    const context = (value, ctx) => {
+        const issuesBefore = ctx?.issues.length ?? 0;
+        const helpers = createHelpers(ctx);
+        const result = parser(value, helpers);
+        // If parser returned null and no child issues were added, add this guard's error
+        if (result === null && ctx?.issues.length === issuesBefore) {
+            ctx.addIssue(formatErrorMessage(value, name));
+        }
+        // Return accumulated issues if any
+        if (ctx && ctx.issues.length > 0) {
+            return { issues: ctx.issues };
+        }
+        if (result !== null) {
+            // Special case: isNull parser returns `true` when value is null
+            return { value: result === true && value === null ? value : result };
+        }
+        return { issues: [{ message: formatErrorMessage(value, name) }] };
+    };
+    const callback = (value) => parser(value, defaultHelpers) !== null;
+    callback._ = { name, parser, context };
+    /**
+     * Creates a new type guard that checks if the value is of type T1 or T2.
+     * This is useful for creating unions of types.
+     * @param {Function} guard A type guard for T2
+     * @returns {Function} A new type guard that checks if the value is of type T1 or T2
+     */
+    callback.or = createOrTypeGuard(callback);
+    function extend(...args) {
+        const parserOrShape = args.length === 1 ? args[0] : args[1];
+        const extendName = args.length === 2 ? args[0] : undefined;
+        // Build a combined parser that first checks the base guard, then the extension
+        let combinedParser;
+        if (isTypeGuardShape(parserOrShape)) {
+            const shapeGuard = createTypeGuard(parserOrShape);
+            combinedParser = (v) => callback(v) && shapeGuard(v) ? v : null;
+        }
+        else {
+            combinedParser = (v, h) => callback(v) ? parserOrShape(v, h) : null;
+        }
+        if (extendName) {
+            return createTypeGuard(extendName, combinedParser);
+        }
+        return createTypeGuard(combinedParser);
+    }
+    callback.extend = extend;
+    /**
+     * Returns false if the value fails the "empty" type guard
+     * or if it fails the parser.
+     * @param {unknown} value
+     * @returns
+     */
+    callback.notEmpty = createNotEmptyTypeGuard(callback);
+    /**
+     * Returns true if the value is undefined or passes the parser.
+     * @param {unknown} value
+     * @returns
+     */
+    const optional = (value) => isUndefined(value) || callback(value);
+    optional.strict = createStrictTypeGuard((v, h) => isUndefined(v) ? v : parser(v, h), name ? `${name} | undefined` : undefined);
+    optional.assert = optional.strict;
+    optional.validate = (value) => isUndefined(value) ? { value } : context(value, createContext());
+    optional.or = createOrTypeGuard(optional);
+    optional.notEmpty = callback.notEmpty.optional;
+    callback.optional = optional;
+    /**
+     * Throws a TypeError if the type guard fails. Optionally you may define an
+     * error message to be included.
+     * @param {unknown} value
+     * @param {string?} errorMsg Optional
+     * @returns
+     */
+    callback.strict = createStrictTypeGuard(parser, name);
+    callback.assert = callback.strict;
+    // StandardSchemaV1 compatibility - uses context-aware validation for path tracking
+    callback.validate = (value) => context(value, createContext());
+    callback["~standard"] = {
+        version: 1,
+        vendor: "guardis",
+        validate: callback.validate,
+    };
+    // Attach the type to the function for easy access
+    return ((t) => t)(callback);
+}
+function isParser(entry) {
+    return typeof entry === "function";
+}
+function isNamedParser(entry) {
+    return typeof entry === "object" && "parse" in entry && typeof entry.parse === "function";
+}
+/**
+ * Converts a ParserEntry (parser function, named parser object, or shape) into a TypeGuard.
+ * Shared by `batch` and `extend` to avoid duplicating entry detection logic.
+ */
+export function entryToGuard(entry) {
+    if (isParser(entry))
+        return createTypeGuard(entry);
+    if (isNamedParser(entry))
+        return createTypeGuard(entry.name, entry.parse);
+    return createTypeGuard(entry);
+}
+/**
+ * Returns true if input satisfies type boolean.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isBoolean = createTypeGuard("boolean", (t) => typeof t === "boolean" ? t : null);
+/**
+ * Returns true if input satisfies type string.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isString = createTypeGuard("string", (t) => typeof t === "string" ? t : null);
+/**
+ * Returns true if input satisfies type number. Returns false if `NaN` is passed.
+ *
+ * While `NaN` is technically a number in JavaScript, it is not a valid value for many applications
+ * and will fail if used with common numeric operations.
+ *
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isNumber = createTypeGuard("number", (t) => typeof t === "number" && !Number.isNaN(t) ? t : null);
+/**
+ * Returns true if input satisfies type symbol.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isSymbol = createTypeGuard("symbol", (t) => typeof t === "symbol" ? t : null);
+/**
+ * Returns true if input satisfies type binary.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isBinary = createTypeGuard("binary", (t) => t === 1 || t === 0 ? t : null);
+/**
+ * Returns true if input satisfies type numeric.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isNumeric = createTypeGuard("numeric", (t) => {
+    if (isNumber(t))
+        return t;
+    if (!/^-?\d*\.?\d+$/.test(t))
+        return null;
+    const _t = parseInt(t) || parseFloat(t);
+    return (!isNaN(_t) && isNumber(_t)) ? t : null;
+});
+/**
+ * Returns true if input satisfies type Function.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isFunction = createTypeGuard("function", (t) => typeof t === "function" ? t : null);
+/**
+ * Returns true if input satisfies type undefined.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isUndefined = createTypeGuard("undefined", (t) => t === undefined ? t : null);
+/**
+ * Returns true if input satisfies type null.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+const isNull = createTypeGuard("null", (t) => (t === null ? true : null));
+/**
+ * Returns true if input is a JSON-able primitive date type
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isJsonPrimitive = unionOf(isBoolean, isString, isNumber, isNull);
+/**
+ * Returns true if input satisfies type object. _BEWARE_ object
+ * can apply to many different types, including arrays. This
+ * is not as type safe as you might think.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isObject = createTypeGuard("object", (t) => t && typeof t === "object" && !Array.isArray(t) ? t : null);
+/** Returns true if input satisfies type PropertyKey.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isPropertyKey = unionOf(isString, isNumber, isSymbol);
+/**
+ * Returns true if input satisfies type object. _BEWARE_ object
+ * can apply to many different types, including arrays. This
+ * is not as type safe as you might think.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isJsonObject = createTypeGuard("JsonObject", (t) => {
+    if (t && typeof t === "object" &&
+        Object.getPrototypeOf(t) === Object.prototype) {
+        for (const v of Object.values(t)) {
+            if (!isJsonValue(v))
+                return null;
+        }
+        return t;
+    }
+    return null;
+});
+/** Precursor to full isArray guard */
+const _isArray = createTypeGuard("array", (t) => Array.isArray(t) ? t : null);
+/**
+ * Returns true if input satisfies type array.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isArray = Object.assign(_isArray, {
+    of: (guard) => {
+        const guardName = hasName(guard) ? guard._.name : undefined;
+        let name = "array";
+        if (guardName) {
+            name = guardName?.includes(" | ") ? `(${guardName})[]` : `${guardName}[]`;
+        }
+        return createTypeGuard(name, (v, helpers) => {
+            if (!isArray(v))
+                return null;
+            const ctx = helpers._ctx;
+            // If we have a context, use index-aware validation
+            if (ctx && hasContext(guard)) {
+                for (let i = 0; i < v.length; i++) {
+                    const childCtx = ctx.pushPath(i);
+                    const result = guard._.context(v[i], childCtx);
+                    if (result.issues)
+                        return null; // issues already added to parent ctx
+                }
+                return v;
+            }
+            // Otherwise, use simple boolean check
+            return v.every((item) => guard(item)) ? v : null;
+        });
+    },
+});
+/**
+ * Returns true if input satisfies type array.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+export const isJsonArray = createTypeGuard("JsonArray", (t) => Array.isArray(t) ? t : null);
+/**
+ * Checks if a given value is a valid JSON value.
+ *
+ * This type guard leverages helper functions to determine if the provided value is a valid JSON
+ * primitive, JSON array, or JSON object. If the value satisfies any of these conditions, it is
+ * considered a valid JSON value.
+ *
+ * @param t - The value to be checked.
+ * @returns The value itself if it is a valid JSON value; otherwise, returns null.
+ *
+ * @remarks
+ * - For primitive types, arrays, and objects, the guard confirms conformance with the JSON value standards.
+ *
+ * @example
+ * const value: unknown = getValue();
+ * const jsonValue = isJsonValue(value);
+ * if (jsonValue !== null) {
+ *   // Work with the confirmed JSON value.
+ * }
+ */
+export const isJsonValue = unionOf(isJsonPrimitive, isJsonArray, isJsonObject);
+/**
+ * A type guard function that checks if a value is a Date object.
+ *
+ * @param t - The value to check
+ * @returns The original Date object if the value is a Date, otherwise null
+ *
+ * @example
+ * ```typescript
+ * const maybeDate: unknown = new Date();
+ *
+ * if (isDate(maybeDate)) {
+ *   // maybeDate is now typed as Date
+ *   console.log(maybeDate.toISOString());
+ * }
+ * ```
+ */
+export const isDate = createTypeGuard("Date", (t) => t instanceof Date ? t : null);
+/**
+ * Returns true if input satisfies type null or undefined.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+const isNil = isNull.or(isUndefined);
+const isEmptyRecord = createTypeGuard("{}", (t) => {
+    if (t && typeof t === "object" && Object.getPrototypeOf(t) === Object.prototype &&
+        Object.keys(t).length === 0) {
+        return t;
+    }
+    return null;
+});
+const isEmptyArray = createTypeGuard("[]", (t) => Array.isArray(t) && t.length === 0 ? t : null);
+const isEmptyString = createTypeGuard('""', (t) => typeof t === "string" ? t === "" ? t : t?.trim?.() === "" ? t : null : null);
+/**
+ * Returns true if input is undefined, null, empty string, object with length
+ * of 0 or object without enumerable keys.
+ *
+ * Strings are trimmed when evaluated.
+ * @param {unknown} t
+ * @return {boolean}
+ */
+const isEmpty = isNull
+    .or(isUndefined)
+    .or(isEmptyString)
+    .or(isEmptyArray)
+    .or(isEmptyRecord);
+/**
+ * Returns true if the value is iterable (has Symbol.iterator). Does not
+ * check the type contained within the iterable.
+ * @param t
+ * @returns
+ */
+const isIterable = createTypeGuard("Iterable", (t) => {
+    if (typeof t === "object" &&
+        !isNil(t) &&
+        Symbol.iterator in t &&
+        isFunction(t[Symbol.iterator])) {
+        return t;
+    }
+    return null;
+});
+/**
+ * Type guard that checks if a value is a tuple (array) of a specific length.
+ *
+ * A tuple is an array with a fixed number of elements. This function validates
+ * that the input is an array and has exactly the specified length.
+ *
+ * @typeParam N - The expected length of the tuple
+ * @param t - The value to check
+ * @param length - The expected length of the tuple
+ * @returns Type predicate indicating if the value is a tuple of length N
+ *
+ * @example
+ * ```typescript
+ * const value: unknown = [1, 2, 3];
+ *
+ * if (isTuple(value, 3)) {
+ *   // value is now typed as [unknown, unknown, unknown]
+ *   console.log(value.length); // 3
+ * }
+ *
+ * // Check for empty tuple
+ * if (isTuple([], 0)) {
+ *   console.log("Empty tuple");
+ * }
+ * ```
+ */
+const isTuple = (t, length) => {
+    return Array.isArray(t) && t.length === length;
+};
+/**
+ * Strict version of isTuple that throws a TypeError if the value is not a tuple of the specified length.
+ * @typeParam N - The expected length of the tuple
+ * @param t - The value to check
+ * @param length - The expected length of the tuple
+ * @param errorMsg - Optional custom error message
+ * @returns true if the value is a tuple of the specified length
+ * @throws {TypeError} If the value is not a tuple of the specified length
+ */
+isTuple.strict = (t, length, errorMsg) => {
+    if (!isTuple(t, length)) {
+        throw TypeError(errorMsg ?? `Type guard failed. Value is not a tuple of length ${length}.`);
+    }
+    return true;
+};
+/**
+ * Assertion function that throws an error if the value is not a tuple of the specified length.
+ * TypeScript will narrow the type to TupleOfLength<N> after this assertion.
+ * @typeParam N - The expected length of the tuple
+ * @param t - The value to check
+ * @param length - The expected length of the tuple
+ * @param errorMsg - Optional custom error message
+ * @throws {TypeError} If the value is not a tuple of the specified length
+ */
+isTuple.assert = isTuple.strict;
+/**
+ * Creates a union type guard that checks if a value is a tuple of specified length OR matches another type.
+ * @param length - The expected length of the tuple
+ * @param guard - The type guard to combine with isTuple
+ * @returns A new type guard for TupleOfLength<N> | T2
+ */
+isTuple.or = (length, guard) => {
+    return createTypeGuard((v) => isTuple(v, length) ? v : guard._.parser(v, defaultHelpers));
+};
+// Define the optional methods for isTuple
+const isTupleOptional = (t, length) => isUndefined(t) || isTuple(t, length);
+isTupleOptional.strict = (t, length, errorMsg) => {
+    if (!isTupleOptional(t, length)) {
+        throw TypeError(errorMsg ?? `Type guard failed. Value is not a tuple of length ${length} or undefined.`);
+    }
+    return true;
+};
+isTupleOptional.assert = isTupleOptional.strict;
+/**
+ * Optional variant of isTuple that accepts undefined or a tuple of the specified length.
+ * @typeParam N - The expected length of the tuple
+ * @param t - The value to check
+ * @param length - The expected length of the tuple
+ * @returns true if the value is undefined or a tuple of the specified length, otherwise false
+ */
+isTuple.optional = isTupleOptional;
+export { isEmpty, isIterable, isNil, isNull, isTuple };

package/esm/src/helpers/http.helpers.d.ts

@@ -0,0 +1,3 @@
+export declare const IPV4_REGEX: RegExp;
+export declare const IPV6_REGEX: RegExp;
+//# sourceMappingURL=http.helpers.d.ts.map

package/esm/src/helpers/http.helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.helpers.d.ts","sourceRoot":"","sources":["../../../src/src/helpers/http.helpers.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,QAAiD,CAAC;AACzE,eAAO,MAAM,UAAU,QAC6F,CAAC"}

package/esm/src/helpers/http.helpers.js

@@ -0,0 +1,2 @@
+export const IPV4_REGEX = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
+export const IPV6_REGEX = /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^([0-9a-fA-F]{1,4}:)*::([0-9a-fA-F]{1,4}:)*[0-9a-fA-F]{1,4}$|^::1$|^::$/;

package/esm/src/helpers/strings.helpers.d.ts

@@ -0,0 +1,18 @@
+export declare function splitToWords(input: string): [] | RegExpMatchArray;
+export declare function capitalizeWord(word: string): string;
+/**
+ * Converts a string into PascalCase.
+ *
+ * @example Usage
+ * ```ts
+ * import { toPascalCase } from "@std/text/to-pascal-case";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toPascalCase("deno is awesome"), "DenoIsAwesome");
+ * ```
+ *
+ * @param input The string that is going to be converted into PascalCase
+ * @returns The string as PascalCase
+ */
+export declare function toPascalCase(input: string): string;
+//# sourceMappingURL=strings.helpers.d.ts.map

package/esm/src/helpers/strings.helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings.helpers.d.ts","sourceRoot":"","sources":["../../../src/src/helpers/strings.helpers.ts"],"names":[],"mappings":"AAiCA,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,yBAEzC;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGlD"}