@cookbook/urlkit 1.0.0

package/dist/compile-path-wQfWAzOh.js

@@ -0,0 +1,1318 @@
+import compile from '@cookbook/pathkit/compile';
+import match from '@cookbook/pathkit/match';
+import { hasConstraint, getConstraint, registerConstraint, createConstraint } from '@cookbook/pathkit/constraints';
+
+const defaultMessages = {
+    'invalid-url': 'Invalid URL.',
+    'path-mismatch': 'Pathname does not match the URL pattern.',
+    'missing-param': 'Required path parameter is missing.',
+    'invalid-param': 'Path parameter is invalid.',
+    'missing-search': 'Required search parameter is missing.',
+    'invalid-search': 'Search parameter is invalid.',
+    'invalid-hash': 'Hash fragment is invalid.',
+    'invalid-descriptor': 'URL descriptor is invalid.',
+};
+function resolveMessage(code, messageOrOptions) {
+    if (typeof messageOrOptions === 'string') {
+        return messageOrOptions;
+    }
+    return defaultMessages[code];
+}
+function resolveOptions(messageOrOptions, options) {
+    if (typeof messageOrOptions === 'string') {
+        return options;
+    }
+    return messageOrOptions;
+}
+function hasCause(options) {
+    return Boolean(options && 'cause' in options);
+}
+class UrlKitError extends Error {
+    code;
+    path;
+    cause;
+    constructor(code, messageOrOptions, options) {
+        const resolvedOptions = resolveOptions(messageOrOptions, options);
+        super(resolveMessage(code, messageOrOptions), hasCause(resolvedOptions) ? { cause: resolvedOptions.cause } : undefined);
+        this.name = 'UrlKitError';
+        this.code = code;
+        if (resolvedOptions?.path) {
+            this.path = [...resolvedOptions.path];
+        }
+        if (hasCause(resolvedOptions)) {
+            this.cause = resolvedOptions.cause;
+        }
+    }
+}
+
+function registerPathConstraint(name, constraint, options = {}) {
+    assertPathConstraintName(name);
+    assertPathConstraint(name, constraint);
+    const existing = getConstraint(name);
+    if (existing && existing !== constraint && !options.overwrite) {
+        throw new UrlKitError('invalid-descriptor', `Path constraint "${name}" is already registered.`, {
+            path: ['pathConstraints', name],
+        });
+    }
+    if (existing === constraint && !options.overwrite) {
+        return;
+    }
+    registerConstraint(name, constraint);
+}
+function registerPathConstraints(constraints, options = {}) {
+    assertPathConstraintMap(constraints);
+    for (const [name, constraint] of Object.entries(constraints)) {
+        registerPathConstraint(name, constraint, options);
+    }
+}
+function hasPathConstraint(name) {
+    return hasConstraint(name);
+}
+function assertPathConstraintName(name) {
+    if (typeof name === 'string' && name.trim()) {
+        return;
+    }
+    throw new UrlKitError('invalid-descriptor', 'Path constraint name must be a non-empty string.', {
+        path: ['pathConstraints'],
+    });
+}
+function assertPathConstraintMap(input) {
+    if (isRecord$2(input)) {
+        return;
+    }
+    throw new UrlKitError('invalid-descriptor', 'Path constraints must be an object.', {
+        path: ['pathConstraints'],
+    });
+}
+function assertPathConstraint(name, constraint) {
+    if (typeof constraint === 'function' &&
+        typeof constraint.verify === 'function' &&
+        typeof constraint.toRegExp === 'function') {
+        return;
+    }
+    throw new UrlKitError('invalid-descriptor', `Path constraint "${name}" must be created with createConstraint().`, {
+        path: ['pathConstraints', name],
+    });
+}
+function isRecord$2(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}
+
+const runtimeSchemaSymbol = Symbol('urlkit.runtime-schema');
+
+function getRuntimeSchemaInternals(schema) {
+    const candidate = schema;
+    const internals = candidate[runtimeSchemaSymbol];
+    if (!internals) {
+        throw new UrlKitError('invalid-descriptor', 'Expected a runtime schema builder.');
+    }
+    return internals;
+}
+
+function compileRuntimeSchema(schema, options = {}) {
+    const internals = getRuntimeSchemaInternals(schema);
+    const descriptor = internals.toDescriptor();
+    if (internals.validateDescriptor) {
+        internals.validateDescriptor({
+            kind: descriptor.kind,
+            path: [...(options.path ?? [])],
+        });
+    }
+    if (descriptor.presence === 'defaulted' && internals.validateDefault) {
+        internals.validateDefault(descriptor.defaultValue, {
+            kind: descriptor.kind,
+            path: [...(options.path ?? [])],
+        });
+    }
+    return descriptor;
+}
+
+function createRuntimeSchemaBuilder(definition) {
+    return createBuilder({
+        kind: definition.kind,
+        presence: 'required',
+        options: copyOptions(definition.options),
+        ...(definition.codec ? { codec: definition.codec } : {}),
+        ...(definition.validateDefault ? { validateDefault: definition.validateDefault } : {}),
+        ...(definition.validateDescriptor ? { validateDescriptor: definition.validateDescriptor } : {}),
+    });
+}
+function createBuilder(state) {
+    const internals = Object.freeze({
+        kind: state.kind,
+        presence: state.presence,
+        options: state.options,
+        ...(state.defaultValue !== undefined ? { defaultValue: state.defaultValue } : {}),
+        ...(state.codec ? { codec: state.codec } : {}),
+        ...(state.validateDefault ? { validateDefault: state.validateDefault } : {}),
+        ...(state.validateDescriptor ? { validateDescriptor: state.validateDescriptor } : {}),
+        toDescriptor: () => createDescriptor(state),
+    });
+    const builder = {
+        [runtimeSchemaSymbol]: internals,
+        optional: () => {
+            const nextState = {
+                kind: state.kind,
+                presence: 'optional',
+                options: state.options,
+                ...(state.codec ? { codec: state.codec } : {}),
+                ...(state.validateDefault
+                    ? { validateDefault: state.validateDefault }
+                    : {}),
+                ...(state.validateDescriptor ? { validateDescriptor: state.validateDescriptor } : {}),
+            };
+            return createBuilder(nextState);
+        },
+        required: () => {
+            const nextState = {
+                kind: state.kind,
+                presence: 'required',
+                options: state.options,
+                ...(state.codec ? { codec: state.codec } : {}),
+                ...(state.validateDefault
+                    ? {
+                        validateDefault: state.validateDefault,
+                    }
+                    : {}),
+                ...(state.validateDescriptor ? { validateDescriptor: state.validateDescriptor } : {}),
+            };
+            return createBuilder(nextState);
+        },
+        default: (value) => {
+            const nextState = {
+                kind: state.kind,
+                presence: 'defaulted',
+                options: state.options,
+                defaultValue: value,
+                ...(state.codec ? { codec: state.codec } : {}),
+                ...(state.validateDefault
+                    ? {
+                        validateDefault: state.validateDefault,
+                    }
+                    : {}),
+                ...(state.validateDescriptor ? { validateDescriptor: state.validateDescriptor } : {}),
+            };
+            return createBuilder(nextState);
+        },
+    };
+    return Object.freeze(builder);
+}
+function createDescriptor(state) {
+    const base = {
+        kind: state.kind,
+        presence: state.presence,
+        options: copyOptions(state.options),
+    };
+    if (state.presence === 'defaulted') {
+        return Object.freeze({
+            ...base,
+            presence: 'defaulted',
+            defaultValue: state.defaultValue,
+        });
+    }
+    return Object.freeze(base);
+}
+function copyOptions(options) {
+    return Object.freeze({ ...(options ?? {}) });
+}
+
+function createSchemaValueError(code, message, path, cause) {
+    return new UrlKitError(code, message, {
+        path,
+        ...(cause !== undefined ? { cause } : {}),
+    });
+}
+
+function compileRuntimeSchemaValue(schema, options = {}) {
+    const descriptor = compileRuntimeSchema(schema, options);
+    const internals = getRuntimeSchemaInternals(schema);
+    return Object.freeze({
+        descriptor: descriptor,
+        ...(internals.codec ? { codec: internals.codec } : {}),
+    });
+}
+
+function handleRuntimeSchemaAbsence(descriptor, input, options = {}) {
+    if (input !== undefined && input !== null) {
+        return { handled: false };
+    }
+    if (descriptor.presence === 'optional') {
+        return { handled: true, value: undefined };
+    }
+    if (descriptor.presence === 'defaulted') {
+        return { handled: true, value: descriptor.defaultValue };
+    }
+    const path = [...(options.path ?? [])];
+    if (input === null) {
+        throw new UrlKitError(options.errorCode ?? 'invalid-search', 'Required value cannot be null.', {
+            path,
+        });
+    }
+    throw new UrlKitError(options.missingCode ?? 'missing-search', 'Required value is missing.', {
+        path,
+    });
+}
+
+function createRuntimeSchemaValueContext(kind, options = {}) {
+    return {
+        kind,
+        path: [...(options.path ?? [])],
+        errorCode: options.errorCode ?? 'invalid-search',
+    };
+}
+
+function normalizeCompiledRuntimeSchemaValue(compiled, input, options = {}) {
+    const absence = handleRuntimeSchemaAbsence(compiled.descriptor, input, options);
+    if (absence.handled) {
+        return absence.value;
+    }
+    if (!compiled.codec) {
+        throw new UrlKitError('invalid-descriptor', `Runtime schema "${compiled.descriptor.kind}" does not define a normalizer.`, options.path ? { path: options.path } : undefined);
+    }
+    try {
+        return compiled.codec.normalize(input, createRuntimeSchemaValueContext(compiled.descriptor.kind, options));
+    }
+    catch (error) {
+        if (error instanceof UrlKitError) {
+            throw error;
+        }
+        throw createSchemaValueError(options.errorCode ?? 'invalid-search', 'Schema value is invalid.', options.path ?? [], error);
+    }
+}
+
+function normalizeRuntimeSchemaValue(schema, input, options = {}) {
+    return normalizeCompiledRuntimeSchemaValue(compileRuntimeSchemaValue(schema, options), input, options);
+}
+
+const booleanCodec = {
+    parse(input, context) {
+        if (input === 'true') {
+            return true;
+        }
+        if (input === 'false') {
+            return false;
+        }
+        throw createSchemaValueError(context.errorCode, 'Expected "true" or "false".', context.path);
+    },
+    normalize(input, context) {
+        return validateBoolean(input, context);
+    },
+    serialize(input, context) {
+        return validateBoolean(input, context) ? 'true' : 'false';
+    },
+};
+function boolean() {
+    return createRuntimeSchemaBuilder({
+        kind: 'boolean',
+        codec: booleanCodec,
+        validateDefault(value, context) {
+            validateBooleanDefault(value, context);
+        },
+    });
+}
+function validateBoolean(input, context) {
+    if (typeof input === 'boolean') {
+        return input;
+    }
+    throw createSchemaValueError(context.errorCode, 'Expected a boolean value.', context.path);
+}
+function validateBooleanDefault(value, context) {
+    if (typeof value === 'boolean') {
+        return;
+    }
+    throw new UrlKitError('invalid-descriptor', 'Boolean schema default must be a boolean.', {
+        path: context.path,
+    });
+}
+
+const datePattern = /^(\d{4})-(\d{2})-(\d{2})$/;
+function parseDate(input, options = {}) {
+    const match = datePattern.exec(input);
+    if (!match) {
+        throw createInvalidDateError('Date value must use YYYY-MM-DD format.', options);
+    }
+    const [, yearText, monthText, dayText] = match;
+    const year = Number(yearText);
+    const month = Number(monthText);
+    const day = Number(dayText);
+    if (month < 1 || month > 12 || day < 1 || day > 31) {
+        throw createInvalidDateError('Date value must be a valid calendar date.', options);
+    }
+    const value = new Date(Date.UTC(0, month - 1, day));
+    value.setUTCFullYear(year);
+    if (value.getUTCFullYear() !== year ||
+        value.getUTCMonth() !== month - 1 ||
+        value.getUTCDate() !== day ||
+        value.getUTCHours() !== 0 ||
+        value.getUTCMinutes() !== 0 ||
+        value.getUTCSeconds() !== 0 ||
+        value.getUTCMilliseconds() !== 0) {
+        throw createInvalidDateError('Date value must be a valid calendar date.', options);
+    }
+    return value;
+}
+function createInvalidDateError(message, options) {
+    return new UrlKitError(options.code ?? 'invalid-search', message, {
+        path: [...(options.path ?? [])],
+    });
+}
+
+function parseCustomDate(input, format, options = {}) {
+    let value;
+    try {
+        value = format.parse(input);
+    }
+    catch (cause) {
+        throw createInvalidCustomDateError$1('Custom date format parser failed.', options, cause);
+    }
+    if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
+        throw createInvalidCustomDateError$1('Custom date format parser must return a valid Date.', options);
+    }
+    return value;
+}
+function createInvalidCustomDateError$1(message, options, cause) {
+    return new UrlKitError(options.code ?? 'invalid-search', message, {
+        path: [...(options.path ?? [])],
+        ...(cause !== undefined ? { cause } : {}),
+    });
+}
+
+const dateTimePattern = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.(\d{3})Z$/;
+function parseDateTime(input, options = {}) {
+    const match = dateTimePattern.exec(input);
+    if (!match) {
+        throw createInvalidDateTimeError$1('Date-time value must use UTC YYYY-MM-DDTHH:mm:ss.sssZ format.', options);
+    }
+    const [, yearText, monthText, dayText, hourText, minuteText, secondText, millisecondText] = match;
+    const year = Number(yearText);
+    const month = Number(monthText);
+    const day = Number(dayText);
+    const hour = Number(hourText);
+    const minute = Number(minuteText);
+    const second = Number(secondText);
+    const millisecond = Number(millisecondText);
+    if (month < 1 || month > 12 || day < 1 || day > 31 || hour > 23 || minute > 59 || second > 59) {
+        throw createInvalidDateTimeError$1('Date-time value must be a valid UTC calendar instant.', options);
+    }
+    const value = new Date(Date.UTC(0, month - 1, day, hour, minute, second, millisecond));
+    value.setUTCFullYear(year);
+    if (value.getUTCFullYear() !== year ||
+        value.getUTCMonth() !== month - 1 ||
+        value.getUTCDate() !== day ||
+        value.getUTCHours() !== hour ||
+        value.getUTCMinutes() !== minute ||
+        value.getUTCSeconds() !== second ||
+        value.getUTCMilliseconds() !== millisecond) {
+        throw createInvalidDateTimeError$1('Date-time value must be a valid UTC calendar instant.', options);
+    }
+    return value;
+}
+function createInvalidDateTimeError$1(message, options) {
+    return new UrlKitError(options.code ?? 'invalid-search', message, {
+        path: [...(options.path ?? [])],
+    });
+}
+
+const unixIntegerPattern$1 = /^-?\d+$/;
+function parseUnixMs(input, options = {}) {
+    const milliseconds = parseUnixInteger$1(input, 'Unix milliseconds value must be a finite integer.', options);
+    const value = new Date(milliseconds);
+    if (!Number.isFinite(value.getTime())) {
+        throw createInvalidUnixMsError$1('Unix milliseconds value must be a valid Date instant.', options);
+    }
+    return value;
+}
+function parseUnixInteger$1(input, message, options) {
+    if (!unixIntegerPattern$1.test(input)) {
+        throw createInvalidUnixMsError$1(message, options);
+    }
+    const value = Number(input);
+    if (!Number.isFinite(value) || !Number.isInteger(value)) {
+        throw createInvalidUnixMsError$1(message, options);
+    }
+    return value;
+}
+function createInvalidUnixMsError$1(message, options) {
+    return new UrlKitError(options.code ?? 'invalid-search', message, {
+        path: [...(options.path ?? [])],
+    });
+}
+
+const unixIntegerPattern = /^-?\d+$/;
+function parseUnixSeconds(input, options = {}) {
+    const seconds = parseUnixInteger(input, 'Unix seconds value must be a finite integer.', options);
+    const milliseconds = seconds * 1000;
+    const value = new Date(milliseconds);
+    if (!Number.isFinite(milliseconds) || !Number.isFinite(value.getTime())) {
+        throw createInvalidUnixSecondsError$1('Unix seconds value must be a valid Date instant.', options);
+    }
+    return value;
+}
+function parseUnixInteger(input, message, options) {
+    if (!unixIntegerPattern.test(input)) {
+        throw createInvalidUnixSecondsError$1(message, options);
+    }
+    const value = Number(input);
+    if (!Number.isFinite(value) || !Number.isInteger(value)) {
+        throw createInvalidUnixSecondsError$1(message, options);
+    }
+    return value;
+}
+function createInvalidUnixSecondsError$1(message, options) {
+    return new UrlKitError(options.code ?? 'invalid-search', message, {
+        path: [...(options.path ?? [])],
+    });
+}
+
+function serializeDate(input, options = {}) {
+    if (!(input instanceof Date) || !Number.isFinite(input.getTime())) {
+        throw new UrlKitError(options.code ?? 'invalid-search', 'Date value must be a valid Date.', {
+            path: [...(options.path ?? [])],
+        });
+    }
+    const year = String(input.getUTCFullYear()).padStart(4, '0');
+    const month = String(input.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(input.getUTCDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+
+function serializeCustomDate(input, format, options = {}) {
+    if (!(input instanceof Date) || !Number.isFinite(input.getTime())) {
+        throw createInvalidCustomDateError('Custom date format value must be a valid Date.', options);
+    }
+    let value;
+    try {
+        value = format.serialize(input);
+    }
+    catch (cause) {
+        throw createInvalidCustomDateError('Custom date format serializer failed.', options, cause);
+    }
+    if (typeof value !== 'string' || value === '') {
+        throw createInvalidCustomDateError('Custom date format serializer must return a non-empty string.', options);
+    }
+    return value;
+}
+function createInvalidCustomDateError(message, options, cause) {
+    return new UrlKitError(options.code ?? 'invalid-search', message, {
+        path: [...(options.path ?? [])],
+        ...(cause !== undefined ? { cause } : {}),
+    });
+}
+
+const serializedDateTimePattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+function serializeDateTime(input, options = {}) {
+    if (!(input instanceof Date) || !Number.isFinite(input.getTime())) {
+        throw createInvalidDateTimeError('Date-time value must be a valid Date.', options);
+    }
+    const value = input.toISOString();
+    if (!serializedDateTimePattern.test(value)) {
+        throw createInvalidDateTimeError('Date-time value must serialize to YYYY-MM-DDTHH:mm:ss.sssZ.', options);
+    }
+    return value;
+}
+function createInvalidDateTimeError(message, options) {
+    return new UrlKitError(options.code ?? 'invalid-search', message, {
+        path: [...(options.path ?? [])],
+    });
+}
+
+function serializeUnixMs(input, options = {}) {
+    if (!(input instanceof Date) || !Number.isFinite(input.getTime())) {
+        throw createInvalidUnixMsError('Unix milliseconds value must be a valid Date.', options);
+    }
+    const milliseconds = input.getTime();
+    if (!Number.isFinite(milliseconds) || !Number.isInteger(milliseconds)) {
+        throw createInvalidUnixMsError('Unix milliseconds value must serialize to finite integer milliseconds.', options);
+    }
+    return String(milliseconds);
+}
+function createInvalidUnixMsError(message, options) {
+    return new UrlKitError(options.code ?? 'invalid-search', message, {
+        path: [...(options.path ?? [])],
+    });
+}
+
+function serializeUnixSeconds(input, options = {}) {
+    if (!(input instanceof Date) || !Number.isFinite(input.getTime())) {
+        throw createInvalidUnixSecondsError('Unix seconds value must be a valid Date.', options);
+    }
+    const milliseconds = input.getTime();
+    if (!Number.isInteger(milliseconds) || milliseconds % 1000 !== 0) {
+        throw createInvalidUnixSecondsError('Unix seconds value must serialize to finite integer seconds.', options);
+    }
+    const seconds = milliseconds / 1000;
+    if (!Number.isFinite(seconds) || !Number.isInteger(seconds)) {
+        throw createInvalidUnixSecondsError('Unix seconds value must serialize to finite integer seconds.', options);
+    }
+    return String(seconds);
+}
+function createInvalidUnixSecondsError(message, options) {
+    return new UrlKitError(options.code ?? 'invalid-search', message, {
+        path: [...(options.path ?? [])],
+    });
+}
+
+const dateOnlyCodec = {
+    parse(input, context) {
+        return parseDate(input, { code: context.errorCode, path: context.path });
+    },
+    normalize(input, context) {
+        return validateDate(input, context);
+    },
+    serialize(input, context) {
+        return serializeDate(input, { code: context.errorCode, path: context.path });
+    },
+};
+const dateTimeCodec = {
+    parse(input, context) {
+        return parseDateTime(input, { code: context.errorCode, path: context.path });
+    },
+    normalize(input, context) {
+        return validateDate(input, context);
+    },
+    serialize(input, context) {
+        return serializeDateTime(input, { code: context.errorCode, path: context.path });
+    },
+};
+const unixSecondsCodec = {
+    parse(input, context) {
+        return parseUnixSeconds(input, { code: context.errorCode, path: context.path });
+    },
+    normalize(input, context) {
+        return validateDate(input, context);
+    },
+    serialize(input, context) {
+        return serializeUnixSeconds(input, { code: context.errorCode, path: context.path });
+    },
+};
+const unixMsCodec = {
+    parse(input, context) {
+        return parseUnixMs(input, { code: context.errorCode, path: context.path });
+    },
+    normalize(input, context) {
+        return validateDate(input, context);
+    },
+    serialize(input, context) {
+        return serializeUnixMs(input, { code: context.errorCode, path: context.path });
+    },
+};
+function date(options = {}) {
+    const format = resolveDateFormat(options);
+    return createRuntimeSchemaBuilder({
+        kind: 'date',
+        options: { format },
+        codec: getDateCodec(format),
+        validateDefault(value, context) {
+            validateDateDefault(value, context);
+        },
+    });
+}
+function getDateCodec(format) {
+    if (isDateFormatCodec(format)) {
+        return createCustomDateCodec(format);
+    }
+    if (format === 'date-time') {
+        return dateTimeCodec;
+    }
+    if (format === 'unix-seconds') {
+        return unixSecondsCodec;
+    }
+    if (format === 'unix-ms') {
+        return unixMsCodec;
+    }
+    return dateOnlyCodec;
+}
+function createCustomDateCodec(format) {
+    return {
+        parse(input, context) {
+            return parseCustomDate(input, format, { code: context.errorCode, path: context.path });
+        },
+        normalize(input, context) {
+            return validateDate(input, context);
+        },
+        serialize(input, context) {
+            return serializeCustomDate(input, format, { code: context.errorCode, path: context.path });
+        },
+    };
+}
+function resolveDateFormat(options) {
+    if (!isDateOptions(options)) {
+        throw new UrlKitError('invalid-descriptor', 'Date options must be an object.');
+    }
+    const format = options.format ?? 'date';
+    if (isBuiltInDateFormat(format) || isDateFormatCodec(format)) {
+        return format;
+    }
+    throw new UrlKitError('invalid-descriptor', 'Date format must be a supported built-in format or an explicit codec.');
+}
+function isDateOptions(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}
+function isBuiltInDateFormat(input) {
+    return (input === 'date' || input === 'date-time' || input === 'unix-seconds' || input === 'unix-ms');
+}
+function isDateFormatCodec(input) {
+    return (typeof input === 'object' &&
+        input !== null &&
+        typeof input.parse === 'function' &&
+        typeof input.serialize === 'function');
+}
+function validateDate(input, context) {
+    if (input instanceof Date && Number.isFinite(input.getTime())) {
+        return input;
+    }
+    throw createSchemaValueError(context.errorCode, 'Expected a valid Date value.', context.path);
+}
+function validateDateDefault(value, context) {
+    if (value instanceof Date && Number.isFinite(value.getTime())) {
+        return;
+    }
+    throw new UrlKitError('invalid-descriptor', 'Date schema default must be a valid Date.', {
+        path: context.path,
+    });
+}
+
+function enumOf(values) {
+    const normalizedValues = normalizeEnumValues$1(values);
+    const allowedValues = new Set(normalizedValues);
+    const expectedMessage = createExpectedEnumMessage(normalizedValues);
+    const enumCodec = {
+        parse(input, context) {
+            return validateEnumValue(input, allowedValues, expectedMessage, context);
+        },
+        normalize(input, context) {
+            return validateEnumValue(input, allowedValues, expectedMessage, context);
+        },
+        serialize(input, context) {
+            return validateEnumValue(input, allowedValues, expectedMessage, context);
+        },
+    };
+    return createRuntimeSchemaBuilder({
+        kind: 'enum',
+        options: {
+            values: normalizedValues,
+        },
+        codec: enumCodec,
+        validateDefault(value, context) {
+            validateEnumDefault(value, allowedValues, expectedMessage, context);
+        },
+    });
+}
+function normalizeEnumValues$1(values) {
+    if (!Array.isArray(values)) {
+        throw new UrlKitError('invalid-descriptor', 'Enum schema values must be an array.');
+    }
+    if (!values.length) {
+        throw new UrlKitError('invalid-descriptor', 'Enum schema values must not be empty.');
+    }
+    for (const value of values) {
+        if (typeof value !== 'string') {
+            throw new UrlKitError('invalid-descriptor', 'Enum schema values must be strings.');
+        }
+    }
+    return Object.freeze([...values]);
+}
+function validateEnumValue(input, allowedValues, message, context) {
+    if (typeof input === 'string' && allowedValues.has(input)) {
+        return input;
+    }
+    throw createSchemaValueError(context.errorCode, message, context.path);
+}
+function validateEnumDefault(value, allowedValues, message, context) {
+    if (typeof value === 'string' && allowedValues.has(value)) {
+        return;
+    }
+    throw new UrlKitError('invalid-descriptor', `Enum schema default is invalid. ${message}`, {
+        path: context.path,
+    });
+}
+function createExpectedEnumMessage(values) {
+    return `Expected one of: ${values.join(', ')}.`;
+}
+
+const intCodec = {
+    parse(input, context) {
+        return parseFiniteInteger(input, context, 'Expected a finite integer value.');
+    },
+    normalize(input, context) {
+        return validateFiniteInteger(input, context, 'Expected a finite integer value.');
+    },
+    serialize(input, context) {
+        return String(validateFiniteInteger(input, context, 'Expected a finite integer value.'));
+    },
+};
+function int() {
+    return createRuntimeSchemaBuilder({
+        kind: 'int',
+        codec: intCodec,
+        validateDefault(value, context) {
+            validateIntDefault(value, context);
+        },
+    });
+}
+function parseFiniteInteger(input, context, message) {
+    if (!input.trim()) {
+        throw createSchemaValueError(context.errorCode, message, context.path);
+    }
+    return validateFiniteInteger(Number(input), context, message);
+}
+function validateFiniteInteger(input, context, message) {
+    if (typeof input === 'number' && Number.isInteger(input)) {
+        return input;
+    }
+    throw createSchemaValueError(context.errorCode, message, context.path);
+}
+function validateIntDefault(value, context) {
+    if (typeof value === 'number' && Number.isInteger(value)) {
+        return;
+    }
+    throw new UrlKitError('invalid-descriptor', 'Integer schema default must be a finite integer.', {
+        path: context.path,
+    });
+}
+
+const numberCodec = {
+    parse(input, context) {
+        return parseFiniteNumber(input, context, 'Expected a finite number value.');
+    },
+    normalize(input, context) {
+        return validateFiniteNumber(input, context, 'Expected a finite number value.');
+    },
+    serialize(input, context) {
+        return String(validateFiniteNumber(input, context, 'Expected a finite number value.'));
+    },
+};
+function number() {
+    return createRuntimeSchemaBuilder({
+        kind: 'number',
+        codec: numberCodec,
+        validateDefault(value, context) {
+            validateNumberDefault(value, context);
+        },
+    });
+}
+function parseFiniteNumber(input, context, message) {
+    if (!input.trim()) {
+        throw createSchemaValueError(context.errorCode, message, context.path);
+    }
+    return validateFiniteNumber(Number(input), context, message);
+}
+function validateFiniteNumber(input, context, message) {
+    if (typeof input === 'number' && Number.isFinite(input)) {
+        return input;
+    }
+    throw createSchemaValueError(context.errorCode, message, context.path);
+}
+function validateNumberDefault(value, context) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return;
+    }
+    throw new UrlKitError('invalid-descriptor', 'Number schema default must be a finite number.', {
+        path: context.path,
+    });
+}
+
+const stringCodec = {
+    parse(input, context) {
+        return validateString(input, context, 'Expected a string value.');
+    },
+    normalize(input, context) {
+        return validateString(input, context, 'Expected a string value.');
+    },
+    serialize(input, context) {
+        return validateString(input, context, 'Expected a string value.');
+    },
+};
+function string() {
+    return createRuntimeSchemaBuilder({
+        kind: 'string',
+        codec: stringCodec,
+        validateDefault(value, context) {
+            validateStringDefault(value, context);
+        },
+    });
+}
+function validateString(input, context, message) {
+    if (typeof input === 'string') {
+        return input;
+    }
+    throw createSchemaValueError(context.errorCode, message, context.path);
+}
+function validateStringDefault(value, context) {
+    if (typeof value === 'string') {
+        return;
+    }
+    throw new UrlKitError('invalid-descriptor', 'String schema default must be a string.', {
+        path: context.path,
+    });
+}
+
+function compileStaticHashDescriptor(descriptor) {
+    if (Array.isArray(descriptor)) {
+        return Object.freeze({
+            kind: 'enum',
+            presence: 'optional',
+            values: normalizeEnumValues(descriptor),
+        });
+    }
+    if (isStaticStringHashDescriptor(descriptor)) {
+        return compileStaticStringHashDescriptor(descriptor);
+    }
+    if (isStaticEnumHashDescriptor(descriptor)) {
+        return compileStaticEnumHashDescriptor(descriptor);
+    }
+    throw new UrlKitError('invalid-descriptor', 'Hash descriptor must be a string, enum, or enum shorthand descriptor.', {
+        path: ['hash'],
+    });
+}
+function compileStaticStringHashDescriptor(descriptor) {
+    assertOptionalFlag(descriptor.optional);
+    if ('default' in descriptor &&
+        descriptor.default !== undefined &&
+        typeof descriptor.default !== 'string') {
+        throw new UrlKitError('invalid-descriptor', 'String hash default must be a string.', {
+            path: ['hash'],
+        });
+    }
+    if (descriptor.default !== undefined) {
+        return Object.freeze({
+            kind: 'string',
+            presence: 'defaulted',
+            defaultValue: descriptor.default,
+        });
+    }
+    return Object.freeze({ kind: 'string', presence: descriptor.optional ? 'optional' : 'required' });
+}
+function compileStaticEnumHashDescriptor(descriptor) {
+    assertOptionalFlag(descriptor.optional);
+    const values = normalizeEnumValues(descriptor.values);
+    if (descriptor.default !== undefined && !values.includes(descriptor.default)) {
+        throw new UrlKitError('invalid-descriptor', 'Enum hash default must be one of the declared values.', { path: ['hash'] });
+    }
+    if (descriptor.default !== undefined) {
+        return Object.freeze({
+            kind: 'enum',
+            presence: 'defaulted',
+            values,
+            defaultValue: descriptor.default,
+        });
+    }
+    return Object.freeze({
+        kind: 'enum',
+        presence: descriptor.optional ? 'optional' : 'required',
+        values,
+    });
+}
+function normalizeEnumValues(values) {
+    if (!Array.isArray(values) || !values.length) {
+        throw new UrlKitError('invalid-descriptor', 'Enum hash values must be a non-empty array.', {
+            path: ['hash'],
+        });
+    }
+    for (const value of values) {
+        if (typeof value !== 'string') {
+            throw new UrlKitError('invalid-descriptor', 'Enum hash values must be strings.', {
+                path: ['hash'],
+            });
+        }
+    }
+    return Object.freeze(values.map((value) => value));
+}
+function assertOptionalFlag(optional) {
+    if (optional !== undefined && typeof optional !== 'boolean') {
+        throw new UrlKitError('invalid-descriptor', 'Hash optional flag must be a boolean.', {
+            path: ['hash'],
+        });
+    }
+}
+function isStaticStringHashDescriptor(input) {
+    return isRecord$1(input) && input.type === 'string';
+}
+function isStaticEnumHashDescriptor(input) {
+    return isRecord$1(input) && input.type === 'enum';
+}
+function isRecord$1(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}
+
+function isRuntimeSearchField(input) {
+    return typeof input === 'object' && input !== null && 'value' in input;
+}
+
+function normalizeSearchFieldDefault(fieldType, schema, value, path) {
+    if (fieldType === 'many') {
+        if (!Array.isArray(value)) {
+            throw new UrlKitError('invalid-descriptor', 'Many search field default must be an array.', {
+                path,
+            });
+        }
+        return Object.freeze(value.map((item) => normalizeRuntimeSchemaValue(schema, item, {
+            path,
+            errorCode: 'invalid-descriptor',
+            missingCode: 'invalid-descriptor',
+        })));
+    }
+    return normalizeRuntimeSchemaValue(schema, value, {
+        path,
+        errorCode: 'invalid-descriptor',
+        missingCode: 'invalid-descriptor',
+    });
+}
+
+function normalizeSearchFieldType(input) {
+    if (input === undefined || input === 'one') {
+        return 'one';
+    }
+    if (input === 'many') {
+        return 'many';
+    }
+    throw new UrlKitError('invalid-descriptor', 'Search field type must be "one" or "many".');
+}
+
+function compileSearchSchema(schema) {
+    if (!isSearchSchema(schema)) {
+        throw new UrlKitError('invalid-descriptor', 'Search schema must be an object.');
+    }
+    const fields = Object.freeze(Object.entries(schema).map(([key, field]) => compileSearchField(key, field)));
+    const keys = new Set(fields.map((field) => field.key));
+    return Object.freeze({ fields, keys });
+}
+function compileSearchField(key, field) {
+    if (isRuntimeSearchField(field)) {
+        return compileSearchFieldObject(key, field);
+    }
+    return compileSearchRuntimeSchemaField(key, field);
+}
+function compileSearchRuntimeSchemaField(key, schema) {
+    const compiledSchema = compileRuntimeSchemaValue(schema, { path: [key] });
+    const descriptor = compiledSchema.descriptor;
+    return Object.freeze({
+        key,
+        type: 'one',
+        schema,
+        compiledSchema,
+        presence: descriptor.presence,
+        ...(descriptor.presence === 'defaulted' ? { defaultValue: descriptor.defaultValue } : {}),
+    });
+}
+function compileSearchFieldObject(key, field) {
+    const path = [key];
+    const fieldType = normalizeSearchFieldType(field.type);
+    getRuntimeSchemaInternals(field.value);
+    const compiledSchema = compileRuntimeSchemaValue(field.value, { path });
+    const descriptor = compiledSchema.descriptor;
+    const hasDefault = Object.prototype.hasOwnProperty.call(field, 'default');
+    const presence = hasDefault
+        ? 'defaulted'
+        : field.optional
+            ? 'optional'
+            : fieldType === 'many'
+                ? 'required'
+                : descriptor.presence;
+    const defaultValue = hasDefault
+        ? normalizeSearchFieldDefault(fieldType, field.value, field.default, path)
+        : descriptor.presence === 'defaulted' && fieldType === 'one'
+            ? descriptor.defaultValue
+            : undefined;
+    return Object.freeze({
+        key,
+        type: fieldType,
+        schema: field.value,
+        compiledSchema,
+        presence,
+        ...(presence === 'defaulted' ? { defaultValue } : {}),
+    });
+}
+function isSearchSchema(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}
+
+function getPathParamKind(segment) {
+    switch (segment.constraint) {
+        case 'int':
+            return 'int';
+        case 'number':
+            return 'number';
+        case 'regex':
+            return 'regex';
+        default:
+            return 'string';
+    }
+}
+
+function assertPathMatchFailure(pattern, pathname, segments) {
+    const pathnameSegments = splitPath(pathname);
+    if (pathnameSegments.length !== segments.length) {
+        throwPathMismatch(pattern, pathname);
+    }
+    for (let index = 0; index < segments.length; index += 1) {
+        const segment = segments[index];
+        const pathnameSegment = pathnameSegments[index];
+        if (!segment || pathnameSegment === undefined) {
+            throwPathMismatch(pattern, pathname);
+        }
+        if (segment.kind === 'literal') {
+            if (segment.value !== pathnameSegment) {
+                throwPathMismatch(pattern, pathname);
+            }
+            continue;
+        }
+        if (!isValidPathParamSegment(segment, pathnameSegment)) {
+            throw new UrlKitError('invalid-param', `Path parameter "${segment.name}" is invalid.`, {
+                path: ['params', segment.name],
+            });
+        }
+    }
+    throwPathMismatch(pattern, pathname);
+}
+function splitPath(pathname) {
+    if (pathname === '') {
+        return Object.freeze([]);
+    }
+    const normalized = pathname.startsWith('/') ? pathname.slice(1) : pathname;
+    if (normalized === '') {
+        return Object.freeze([]);
+    }
+    return Object.freeze(normalized.split('/'));
+}
+function isValidPathParamSegment(segment, value) {
+    if (value === '') {
+        return false;
+    }
+    const kind = getPathParamKind(segment);
+    if (kind === 'int') {
+        return /^\d+$/.test(value);
+    }
+    if (kind === 'number') {
+        return /^-?(?:\d+(?:\.\d+)?|\.\d+)$/.test(value) && Number.isFinite(Number(value));
+    }
+    if (kind === 'regex') {
+        const params = segment.constraintParams;
+        if (!params) {
+            return false;
+        }
+        return new RegExp(`^(?:${params})$`).test(value);
+    }
+    if (segment.constraint) {
+        const constraint = getConstraint(segment.constraint);
+        if (!constraint) {
+            return false;
+        }
+        try {
+            return new RegExp(`^(?:${constraint.toRegExp(segment.constraintParams ?? '')})$`).test(value);
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+}
+function throwPathMismatch(pattern, pathname) {
+    throw new UrlKitError('path-mismatch', `Pathname "${pathname}" does not match pattern "${pattern}".`, {
+        path: ['pathname'],
+    });
+}
+
+function coercePathParam(segment, value, paramsMode) {
+    if (paramsMode === 'raw') {
+        return value;
+    }
+    const kind = getPathParamKind(segment);
+    if (kind === 'int') {
+        const parsed = Number(value);
+        if (!Number.isInteger(parsed)) {
+            throw new UrlKitError('invalid-param', `Path parameter "${segment.name}" must be an integer.`, {
+                path: ['params', segment.name],
+            });
+        }
+        return parsed;
+    }
+    if (kind === 'number') {
+        const parsed = Number(value);
+        if (!Number.isFinite(parsed)) {
+            throw new UrlKitError('invalid-param', `Path parameter "${segment.name}" must be a finite number.`, {
+                path: ['params', segment.name],
+            });
+        }
+        return parsed;
+    }
+    return value;
+}
+
+function normalizePathBuildParams(params) {
+    if (params === undefined) {
+        return {};
+    }
+    if (!isRecord(params)) {
+        throw new UrlKitError('invalid-param', 'Path params must be an object.', { path: ['params'] });
+    }
+    const normalized = {};
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === null) {
+            throw new UrlKitError('missing-param', `Path parameter "${key}" is required.`, {
+                path: ['params', key],
+            });
+        }
+        if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
+            throw new UrlKitError('invalid-param', `Path parameter "${key}" must be a string, number, or boolean.`, {
+                path: ['params', key],
+            });
+        }
+        normalized[key] = value;
+    }
+    return normalized;
+}
+function isRecord(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}
+
+function parsePathPattern(pattern) {
+    if (pattern === '') {
+        return Object.freeze([]);
+    }
+    const normalized = pattern.startsWith('/') ? pattern.slice(1) : pattern;
+    if (normalized === '') {
+        return Object.freeze([]);
+    }
+    return Object.freeze(normalized.split('/').map((segment, index) => parsePathSegment(segment, index)));
+}
+function parsePathSegment(segment, index) {
+    if (!segment.startsWith('{') || !segment.endsWith('}')) {
+        return Object.freeze({ kind: 'literal', value: segment });
+    }
+    const token = segment.slice(1, -1);
+    const parsed = parseParamToken(token);
+    if (!parsed.name) {
+        throw new UrlKitError('invalid-descriptor', 'Path parameter name is required.', {
+            path: ['path', String(index)],
+        });
+    }
+    return Object.freeze({ kind: 'param', ...parsed });
+}
+function parseParamToken(token) {
+    const colonIndex = token.indexOf(':');
+    if (colonIndex === -1) {
+        return { name: token };
+    }
+    const name = token.slice(0, colonIndex);
+    const constraintToken = token.slice(colonIndex + 1);
+    const paramsStart = constraintToken.indexOf('(');
+    if (paramsStart === -1 || !constraintToken.endsWith(')')) {
+        return { name, constraint: constraintToken };
+    }
+    return {
+        name,
+        constraint: constraintToken.slice(0, paramsStart),
+        constraintParams: constraintToken.slice(paramsStart + 1, -1),
+    };
+}
+
+const numberConstraint = createConstraint({
+    parse(paramName, value, params) {
+        numberConstraint.verify(paramName, params);
+        const serialized = String(value);
+        if (!isFinitePathNumber(serialized)) {
+            throw new UrlKitError('invalid-param', `Path parameter "${paramName}" must be a finite number.`, {
+                path: ['params', paramName],
+            });
+        }
+    },
+    verify(paramName, params) {
+        if (params.trim()) {
+            throw new UrlKitError('invalid-descriptor', `Constraint 'number' declared for '${paramName}' parameter does not accept arguments.`, { path: ['path', paramName] });
+        }
+    },
+    toRegExp() {
+        return '-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)';
+    },
+});
+function registerUrlKitPathConstraints() {
+    if (!hasConstraint('number')) {
+        registerConstraint('number', numberConstraint);
+    }
+}
+function isFinitePathNumber(value) {
+    if (!/^-?(?:\d+(?:\.\d+)?|\.\d+)$/.test(value)) {
+        return false;
+    }
+    return Number.isFinite(Number(value));
+}
+
+function compilePath(pattern, options = {}) {
+    registerUrlKitPathConstraints();
+    if (options.pathConstraints) {
+        registerPathConstraints(options.pathConstraints);
+    }
+    const paramsMode = options.params ?? 'parsed';
+    const { segments, matcher, builder } = compilePathPattern(pattern);
+    return Object.freeze({
+        pattern,
+        parsePathname(pathname) {
+            const result = matcher(pathname);
+            if (!result.match || !result.params) {
+                assertPathMatchFailure(pattern, pathname, segments);
+            }
+            return Object.freeze(coercePathParams(result.params, segments, paramsMode));
+        },
+        buildPath(params) {
+            try {
+                return builder(normalizePathBuildParams(params));
+            }
+            catch (error) {
+                throw mapBuildPathError(error);
+            }
+        },
+    });
+}
+function coercePathParams(matchedParams, segments, paramsMode) {
+    const params = {};
+    for (const segment of segments) {
+        if (segment.kind !== 'param') {
+            continue;
+        }
+        const value = matchedParams[segment.name];
+        if (typeof value !== 'string') {
+            continue;
+        }
+        params[segment.name] = coercePathParam(segment, value, paramsMode);
+    }
+    return params;
+}
+function mapBuildPathError(error) {
+    if (error instanceof UrlKitError) {
+        return error;
+    }
+    const message = error instanceof Error ? error.message : 'Failed to build pathname.';
+    const missingParamMatch = /Missing required parameter: ([^\s]+)/.exec(message);
+    if (missingParamMatch?.[1]) {
+        return new UrlKitError('missing-param', `Path parameter "${missingParamMatch[1]}" is required.`, {
+            path: ['params', missingParamMatch[1]],
+            cause: error,
+        });
+    }
+    return new UrlKitError('invalid-param', message, {
+        path: ['params'],
+        cause: error,
+    });
+}
+function compilePathPattern(pattern) {
+    try {
+        return Object.freeze({
+            segments: parsePathPattern(pattern),
+            matcher: match(pattern),
+            builder: compile(pattern),
+        });
+    }
+    catch (error) {
+        if (error instanceof UrlKitError) {
+            throw error;
+        }
+        throw new UrlKitError('invalid-descriptor', 'Path pattern is invalid.', {
+            path: ['path'],
+            cause: error,
+        });
+    }
+}
+
+export { UrlKitError as U, compilePath as a, boolean as b, compileSearchSchema as c, date as d, enumOf as e, registerPathConstraints as f, handleRuntimeSchemaAbsence as g, hasPathConstraint as h, int as i, createSchemaValueError as j, createRuntimeSchemaValueContext as k, compileRuntimeSchemaValue as l, createRuntimeSchemaBuilder as m, number as n, normalizeRuntimeSchemaValue as o, getRuntimeSchemaInternals as p, runtimeSchemaSymbol as q, registerPathConstraint as r, string as s, compileRuntimeSchema as t, normalizeCompiledRuntimeSchemaValue as u, compileStaticHashDescriptor as v, parseUnixSeconds as w, parseUnixMs as x, parseDateTime as y, parseDate as z };
+//# sourceMappingURL=compile-path-wQfWAzOh.js.map