@cookbook/urlkit 1.0.0

package/dist/create-url-contract-BYKPM9bn.js

@@ -0,0 +1,1751 @@
+import { g as handleRuntimeSchemaAbsence, j as createSchemaValueError, U as UrlKitError, k as createRuntimeSchemaValueContext, l as compileRuntimeSchemaValue, m as createRuntimeSchemaBuilder, o as normalizeRuntimeSchemaValue, p as getRuntimeSchemaInternals, q as runtimeSchemaSymbol, t as compileRuntimeSchema, u as normalizeCompiledRuntimeSchemaValue, v as compileStaticHashDescriptor, c as compileSearchSchema, a as compilePath } from './compile-path-wQfWAzOh.js';
+
+function parseCompiledRuntimeSchemaValue(compiled, input, options = {}) {
+    const absence = handleRuntimeSchemaAbsence(compiled.descriptor, input, options);
+    if (absence.handled) {
+        return absence.value;
+    }
+    if (typeof input !== 'string') {
+        throw createSchemaValueError(options.errorCode ?? 'invalid-search', 'Serialized schema values must be strings.', options.path ?? []);
+    }
+    if (!compiled.codec) {
+        throw new UrlKitError('invalid-descriptor', `Runtime schema "${compiled.descriptor.kind}" does not define a parser.`, options.path ? { path: options.path } : undefined);
+    }
+    try {
+        return compiled.codec.parse(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 parseRuntimeSchemaValue(schema, input, options = {}) {
+    return parseCompiledRuntimeSchemaValue(compileRuntimeSchemaValue(schema, options), input, options);
+}
+
+function serializeCompiledRuntimeSchemaValue(compiled, input, options = {}) {
+    const absence = handleRuntimeSchemaAbsence(compiled.descriptor, input, options);
+    if (absence.handled) {
+        if (absence.value === undefined) {
+            return undefined;
+        }
+        input = absence.value;
+    }
+    if (!compiled.codec) {
+        throw new UrlKitError('invalid-descriptor', `Runtime schema "${compiled.descriptor.kind}" does not define a serializer.`, options.path ? { path: options.path } : undefined);
+    }
+    try {
+        const context = createRuntimeSchemaValueContext(compiled.descriptor.kind, options);
+        const normalized = compiled.codec.normalize(input, context);
+        return compiled.codec.serialize(normalized, context);
+    }
+    catch (error) {
+        if (error instanceof UrlKitError) {
+            throw error;
+        }
+        throw createSchemaValueError(options.errorCode ?? 'invalid-search', 'Schema value is invalid.', options.path ?? [], error);
+    }
+}
+
+function serializeRuntimeSchemaValue(schema, input, options = {}) {
+    return serializeCompiledRuntimeSchemaValue(compileRuntimeSchemaValue(schema, options), input, options);
+}
+
+const arrayElements = new WeakMap();
+function array(element) {
+    const elementDescriptor = createElementDescriptor(element);
+    const builder = createRuntimeSchemaBuilder({
+        kind: 'array',
+        options: {
+            element: elementDescriptor,
+        },
+        codec: createArrayCodec(element),
+        validateDescriptor(context) {
+            compileRuntimeSchema(element, { path: [...context.path, '*'] });
+        },
+        validateDefault(value, context) {
+            validateArrayDefault(element, value, context);
+        },
+    });
+    return withArrayElement(builder, element);
+}
+function parseArrayRuntimeSchemaValue(schema, input, context) {
+    const values = Array.isArray(input) ? input : [input];
+    const element = getArrayElementSchema(schema);
+    return Object.freeze(values.map((value) => parseRuntimeSchemaValue(element, value, {
+        path: context.path,
+        errorCode: context.errorCode,
+        missingCode: context.errorCode,
+    })));
+}
+function serializeArrayRuntimeSchemaValue(schema, input, context) {
+    const normalized = normalizeRuntimeSchemaValue(schema, input, {
+        path: context.path,
+        errorCode: context.errorCode,
+        missingCode: context.errorCode,
+    });
+    if (!normalized.length) {
+        return undefined;
+    }
+    const element = getArrayElementSchema(schema);
+    return Object.freeze(normalized.map((value) => serializeRuntimeSchemaValue(element, value, {
+        path: context.path,
+        errorCode: context.errorCode,
+        missingCode: context.errorCode,
+    }) ?? ''));
+}
+function withArrayElement(builder, element) {
+    const wrapped = {
+        [runtimeSchemaSymbol]: builder[runtimeSchemaSymbol],
+        optional: () => withArrayElement(builder.optional(), element),
+        required: () => withArrayElement(builder.required(), element),
+        default: (value) => withArrayElement(builder.default(value), element),
+    };
+    arrayElements.set(wrapped, element);
+    return Object.freeze(wrapped);
+}
+function createArrayCodec(schema) {
+    return {
+        parse(input, context) {
+            return Object.freeze([
+                parseRuntimeSchemaValue(schema, input, {
+                    path: context.path,
+                    errorCode: context.errorCode,
+                    missingCode: context.errorCode,
+                }),
+            ]);
+        },
+        normalize(input, context) {
+            if (!Array.isArray(input)) {
+                throw createSchemaValueError(context.errorCode, 'Expected an array value.', context.path);
+            }
+            return Object.freeze(input.map((item) => normalizeRuntimeSchemaValue(schema, item, {
+                path: context.path,
+                errorCode: context.errorCode,
+                missingCode: context.errorCode,
+            })));
+        },
+        serialize() {
+            throw new UrlKitError('invalid-descriptor', 'Array schemas require repeated-key search serialization.');
+        },
+    };
+}
+function validateArrayDefault(schema, value, context) {
+    if (!Array.isArray(value)) {
+        throw new UrlKitError('invalid-descriptor', 'Array schema default must be an array.', {
+            path: context.path,
+        });
+    }
+    for (const item of value) {
+        normalizeRuntimeSchemaValue(schema, item, {
+            path: context.path,
+            errorCode: 'invalid-descriptor',
+            missingCode: 'invalid-descriptor',
+        });
+    }
+}
+function createElementDescriptor(schema) {
+    return getRuntimeSchemaInternals(schema).toDescriptor();
+}
+function getArrayElementSchema(schema) {
+    const element = arrayElements.get(schema);
+    if (element) {
+        return element;
+    }
+    throw new UrlKitError('invalid-descriptor', 'Array schema element is missing.');
+}
+
+const objectShapes = new WeakMap();
+function object(shape) {
+    validateObjectShape(shape);
+    const builder = createRuntimeSchemaBuilder({
+        kind: 'object',
+        options: {
+            shape: createShapeDescriptor(shape),
+        },
+        codec: createObjectCodec(shape),
+        validateDescriptor(context) {
+            validateObjectDescriptor(shape, context);
+        },
+        validateDefault(value, context) {
+            validateObjectDefault(shape, value, context);
+        },
+    });
+    return withObjectShape(builder, shape);
+}
+function withObjectShape(builder, shape) {
+    const wrapped = {
+        [runtimeSchemaSymbol]: builder[runtimeSchemaSymbol],
+        optional: () => withObjectShape(builder.optional(), shape),
+        required: () => withObjectShape(builder.required(), shape),
+        default: (value) => withObjectShape(builder.default(value), shape),
+    };
+    objectShapes.set(wrapped, shape);
+    return Object.freeze(wrapped);
+}
+function getObjectSchemaShape(schema) {
+    const shape = objectShapes.get(schema);
+    if (shape) {
+        return shape;
+    }
+    throw new UrlKitError('invalid-descriptor', 'Object schema shape is missing.');
+}
+function createObjectCodec(shape) {
+    return {
+        parse(_input, context) {
+            throw createSchemaValueError(context.errorCode, 'Object search values must use declared dotted keys.', context.path);
+        },
+        normalize(input, context) {
+            return normalizeObjectValue(shape, input, context);
+        },
+        serialize(_input, context) {
+            throw createSchemaValueError(context.errorCode, 'Object search values must use declared dotted keys.', context.path);
+        },
+    };
+}
+function normalizeObjectValue(shape, input, context) {
+    if (!isPlainObject$3(input)) {
+        throw createSchemaValueError(context.errorCode, 'Expected an object value.', context.path);
+    }
+    const result = {};
+    for (const [key, schema] of Object.entries(shape)) {
+        const value = normalizeRuntimeSchemaValue(schema, input[key], {
+            path: [...context.path, key],
+            errorCode: context.errorCode,
+            missingCode: context.errorCode,
+        });
+        if (value !== undefined) {
+            result[key] = value;
+        }
+    }
+    return Object.freeze(result);
+}
+function validateObjectDefault(shape, value, context) {
+    normalizeObjectValue(shape, value, {
+        path: context.path,
+        errorCode: 'invalid-descriptor',
+    });
+}
+function validateObjectDescriptor(shape, context) {
+    for (const [key, schema] of Object.entries(shape)) {
+        compileRuntimeSchema(schema, { path: [...context.path, key] });
+    }
+}
+function createShapeDescriptor(shape) {
+    const descriptors = {};
+    for (const [key, schema] of Object.entries(shape)) {
+        descriptors[key] = getRuntimeSchemaInternals(schema).toDescriptor();
+    }
+    return Object.freeze(descriptors);
+}
+function validateObjectShape(shape) {
+    if (!isPlainObject$3(shape)) {
+        throw new UrlKitError('invalid-descriptor', 'Object schema shape must be an object.');
+    }
+    for (const [key, schema] of Object.entries(shape)) {
+        if (!key) {
+            throw new UrlKitError('invalid-descriptor', 'Object schema field names must not be empty.');
+        }
+        getRuntimeSchemaInternals(schema);
+    }
+}
+function isPlainObject$3(input) {
+    return (typeof input === 'object' && input !== null && !Array.isArray(input) && !(input instanceof Date));
+}
+
+function copyNormalizedHashDescriptor(descriptor) {
+    const values = descriptor.values ? Object.freeze([...descriptor.values]) : undefined;
+    if (descriptor.presence === 'defaulted') {
+        return Object.freeze({
+            kind: descriptor.kind,
+            presence: 'defaulted',
+            ...(values ? { values } : {}),
+            defaultValue: descriptor.defaultValue,
+        });
+    }
+    return Object.freeze({
+        kind: descriptor.kind,
+        presence: descriptor.presence,
+        ...(values ? { values } : {}),
+    });
+}
+
+const HASH_PATH$2 = Object.freeze(['hash']);
+function validateNormalizedHashValue(descriptor, input, options) {
+    if (input === undefined || input === null) {
+        if (descriptor.presence === 'optional') {
+            return undefined;
+        }
+        if (descriptor.presence === 'defaulted') {
+            return descriptor.defaultValue;
+        }
+        throw new UrlKitError('invalid-hash', input === null ? 'Required hash cannot be null.' : 'Required hash is missing.', {
+            path: HASH_PATH$2,
+        });
+    }
+    if (typeof input !== 'string') {
+        throw new UrlKitError('invalid-hash', options.serialized ? 'Serialized hash must be a string.' : 'Hash must be a string.', { path: HASH_PATH$2 });
+    }
+    if (descriptor.kind === 'enum' && !(descriptor.values ?? []).includes(input)) {
+        throw new UrlKitError('invalid-hash', `Expected hash to be one of: ${(descriptor.values ?? []).join(', ')}.`, {
+            path: HASH_PATH$2,
+        });
+    }
+    return input;
+}
+
+function compileNormalizedHashDescriptor(descriptor) {
+    const normalizedDescriptor = copyNormalizedHashDescriptor(descriptor);
+    return Object.freeze({
+        descriptor: normalizedDescriptor,
+        parse(input) {
+            return validateNormalizedHashValue(normalizedDescriptor, input, { serialized: true });
+        },
+        normalize(input) {
+            return validateNormalizedHashValue(normalizedDescriptor, input, { serialized: false });
+        },
+        serialize(input) {
+            const value = validateNormalizedHashValue(normalizedDescriptor, input, { serialized: false });
+            return value ?? undefined;
+        },
+        isDefault(input) {
+            if (normalizedDescriptor.presence !== 'defaulted') {
+                return false;
+            }
+            return (validateNormalizedHashValue(normalizedDescriptor, input, { serialized: false }) ===
+                normalizedDescriptor.defaultValue);
+        },
+    });
+}
+
+const HASH_PATH$1 = Object.freeze(['hash']);
+function compileRuntimeHashDescriptor(schema) {
+    const compiledSchema = compileRuntimeSchemaValue(schema, { path: HASH_PATH$1 });
+    const descriptor = compiledSchema.descriptor;
+    if (descriptor.kind !== 'string' && descriptor.kind !== 'enum') {
+        throw new UrlKitError('invalid-descriptor', 'Hash schema must be a string or enum schema.', {
+            path: HASH_PATH$1,
+        });
+    }
+    return Object.freeze({
+        descriptor: toNormalizedHashDescriptor(descriptor),
+        parse(input) {
+            return parseCompiledRuntimeSchemaValue(compiledSchema, input, {
+                path: HASH_PATH$1,
+                errorCode: 'invalid-hash',
+                missingCode: 'invalid-hash',
+            });
+        },
+        normalize(input) {
+            return normalizeCompiledRuntimeSchemaValue(compiledSchema, input, {
+                path: HASH_PATH$1,
+                errorCode: 'invalid-hash',
+                missingCode: 'invalid-hash',
+            });
+        },
+        serialize(input) {
+            return serializeCompiledRuntimeSchemaValue(compiledSchema, input, {
+                path: HASH_PATH$1,
+                errorCode: 'invalid-hash',
+                missingCode: 'invalid-hash',
+            });
+        },
+        isDefault(input) {
+            if (descriptor.presence !== 'defaulted') {
+                return false;
+            }
+            return (normalizeCompiledRuntimeSchemaValue(compiledSchema, input, {
+                path: HASH_PATH$1,
+                errorCode: 'invalid-hash',
+                missingCode: 'invalid-hash',
+            }) === descriptor.defaultValue);
+        },
+    });
+}
+function toNormalizedHashDescriptor(descriptor) {
+    const values = isStringArray(descriptor.options.values)
+        ? [...descriptor.options.values]
+        : undefined;
+    if (descriptor.presence === 'defaulted') {
+        return Object.freeze({
+            kind: descriptor.kind,
+            presence: 'defaulted',
+            ...(values ? { values: Object.freeze(values) } : {}),
+            defaultValue: descriptor.defaultValue,
+        });
+    }
+    return Object.freeze({
+        kind: descriptor.kind,
+        presence: descriptor.presence,
+        ...(values ? { values: Object.freeze(values) } : {}),
+    });
+}
+function isStringArray(input) {
+    return Array.isArray(input) && input.every((value) => typeof value === 'string');
+}
+
+function isNormalizedHashDescriptor(input) {
+    return (isRecord$4(input) &&
+        (input.kind === 'string' || input.kind === 'enum') &&
+        (input.presence === 'required' ||
+            input.presence === 'optional' ||
+            input.presence === 'defaulted'));
+}
+function isRecord$4(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}
+
+const HASH_PATH = Object.freeze(['hash']);
+function compileHashDescriptor(descriptor) {
+    if (descriptor === undefined) {
+        return compileNormalizedHashDescriptor({ kind: 'string', presence: 'optional' });
+    }
+    const runtimeKind = getRuntimeSchemaKind(descriptor);
+    if (runtimeKind) {
+        if (runtimeKind !== 'string' && runtimeKind !== 'enum') {
+            throw new UrlKitError('invalid-descriptor', 'Hash schema must be a string or enum schema.', {
+                path: HASH_PATH,
+            });
+        }
+        return compileRuntimeHashDescriptor(descriptor);
+    }
+    if (isNormalizedHashDescriptor(descriptor)) {
+        return compileNormalizedHashDescriptor(descriptor);
+    }
+    return compileNormalizedHashDescriptor(compileStaticHashDescriptor(descriptor));
+}
+function getRuntimeSchemaKind(input) {
+    try {
+        const internals = getRuntimeSchemaInternals(input);
+        return internals.kind;
+    }
+    catch {
+        return undefined;
+    }
+}
+
+function readHashFragment(input) {
+    if (input === undefined || input === null) {
+        return undefined;
+    }
+    if (input instanceof URL) {
+        return readHashFragment(input.hash);
+    }
+    if (typeof input !== 'string') {
+        throw new UrlKitError('invalid-hash', 'Hash must be a string.');
+    }
+    const withoutPrefix = input.startsWith('#') ? input.slice(1) : input;
+    if (!withoutPrefix) {
+        return undefined;
+    }
+    try {
+        return decodeURIComponent(withoutPrefix);
+    }
+    catch (error) {
+        throw new UrlKitError('invalid-hash', 'Hash is not valid URL encoding.', {
+            path: ['hash'],
+            cause: error,
+        });
+    }
+}
+function writeHashFragment(input) {
+    return `#${encodeURIComponent(input)}`;
+}
+
+function buildHash(hash, descriptorOrOptions, options) {
+    const descriptor = isBuildUrlOptions(descriptorOrOptions) ? undefined : descriptorOrOptions;
+    const buildOptions = isBuildUrlOptions(descriptorOrOptions) ? descriptorOrOptions : options;
+    const compiled = compileHashDescriptor(descriptor);
+    if (buildOptions?.defaults === 'omit' &&
+        hash !== undefined &&
+        hash !== null &&
+        compiled.isDefault(hash)) {
+        return '';
+    }
+    if (buildOptions?.defaults === 'omit' &&
+        (hash === undefined || hash === null) &&
+        compiled.descriptor.presence !== 'required') {
+        return '';
+    }
+    const value = compiled.serialize(hash);
+    return value === undefined ? '' : writeHashFragment(value);
+}
+function isBuildUrlOptions(input) {
+    return (typeof input === 'object' && input !== null && !Array.isArray(input) && 'defaults' in input);
+}
+
+function parseHash(input, descriptor) {
+    const hash = readHashFragment(input);
+    if (descriptor === undefined) {
+        return hash;
+    }
+    return compileHashDescriptor(descriptor).parse(hash);
+}
+
+function isRuntimeSchemaKind(schema, kind) {
+    return getRuntimeSchemaInternals(schema).kind === kind;
+}
+
+function appendSearchEntry(entries, key, value, options = {}) {
+    if (value === undefined) {
+        return;
+    }
+    if (typeof value === 'string') {
+        entries.push({ key, value });
+        return;
+    }
+    appendArraySearchEntry(entries, key, value, options);
+}
+function appendArraySearchEntry(entries, key, values, options) {
+    if (!values.length) {
+        return;
+    }
+    if (options.arrayFormat === 'comma') {
+        entries.push({ key, value: values.join(',') });
+        return;
+    }
+    for (const value of values) {
+        entries.push({ key, value });
+    }
+}
+
+function joinObjectSearchKey(parentKey, childKey) {
+    return `${parentKey}.${escapeObjectSearchSegment(childKey)}`;
+}
+function escapeObjectSearchSegment(segment) {
+    return segment.replaceAll('~', '~0').replaceAll('.', '~1');
+}
+function unescapeObjectSearchSegment(segment) {
+    let output = '';
+    for (let index = 0; index < segment.length; index += 1) {
+        const character = segment[index];
+        if (character !== '~') {
+            output += character ?? '';
+            continue;
+        }
+        const escapeCode = segment[index + 1];
+        if (escapeCode === '0') {
+            output += '~';
+            index += 1;
+            continue;
+        }
+        if (escapeCode === '1') {
+            output += '.';
+            index += 1;
+            continue;
+        }
+        output += character ?? '';
+    }
+    return output;
+}
+function splitObjectSearchKey(key) {
+    return Object.freeze(key.split('.').map(unescapeObjectSearchSegment));
+}
+
+function appendObjectSearchEntries(entries, parentKey, schema, value, options = {}) {
+    if (!isPlainObject$2(value)) {
+        return;
+    }
+    const shape = getObjectSchemaShape(schema);
+    for (const [key, childSchema] of Object.entries(shape)) {
+        const childValue = value[key];
+        if (childValue === undefined) {
+            continue;
+        }
+        const childKey = joinObjectSearchKey(parentKey, key);
+        appendObjectChildSearchEntry(entries, childKey, childSchema, childValue, options);
+    }
+}
+function appendObjectChildSearchEntry(entries, key, schema, value, options) {
+    if (isRuntimeSchemaKind(schema, 'object')) {
+        appendObjectSearchEntries(entries, key, schema, value, options);
+        return;
+    }
+    if (isRuntimeSchemaKind(schema, 'array')) {
+        appendSearchEntry(entries, key, serializeArrayRuntimeSchemaValue(schema, value, {
+            path: [key],
+            errorCode: 'invalid-search',
+        }), options);
+        return;
+    }
+    appendSearchEntry(entries, key, serializeRuntimeSchemaValue(schema, value, {
+        path: [key],
+        errorCode: 'invalid-search',
+        missingCode: 'missing-search',
+    }), options);
+}
+function isPlainObject$2(input) {
+    return (typeof input === 'object' && input !== null && !Array.isArray(input) && !(input instanceof Date));
+}
+
+function areSearchValuesEqual(left, right) {
+    if (left instanceof Date || right instanceof Date) {
+        return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
+    }
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return Array.isArray(left) && Array.isArray(right) && areArraysEqual(left, right);
+    }
+    if (isPlainObject$1(left) || isPlainObject$1(right)) {
+        return isPlainObject$1(left) && isPlainObject$1(right) && areObjectsEqual(left, right);
+    }
+    return left === right;
+}
+function areArraysEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((value, index) => areSearchValuesEqual(value, right[index]));
+}
+function areObjectsEqual(left, right) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length) {
+        return false;
+    }
+    return leftKeys.every((key) => Object.prototype.hasOwnProperty.call(right, key) &&
+        areSearchValuesEqual(left[key], right[key]));
+}
+function isPlainObject$1(input) {
+    return (typeof input === 'object' && input !== null && !Array.isArray(input) && !(input instanceof Date));
+}
+
+function normalizeSearchBuildValue(field, input) {
+    if (isRuntimeSchemaKind(field.schema, 'array') || isRuntimeSchemaKind(field.schema, 'object')) {
+        return normalizeCompiledRuntimeSchemaValue(field.compiledSchema, input, {
+            path: [field.key],
+            errorCode: 'invalid-search',
+            missingCode: 'missing-search',
+        });
+    }
+    if (field.type === 'many') {
+        return normalizeManySearchBuildValue(field, input);
+    }
+    return normalizeOneSearchBuildValue(field, input);
+}
+function normalizeOneSearchBuildValue(field, input) {
+    if (input === undefined || input === null) {
+        if (field.presence === 'optional') {
+            return undefined;
+        }
+        if (field.presence === 'defaulted') {
+            return field.defaultValue;
+        }
+        if (input === null) {
+            throw new UrlKitError('invalid-search', 'Required search parameter cannot be null.', {
+                path: [field.key],
+            });
+        }
+        throw new UrlKitError('missing-search', 'Required search parameter is missing.', {
+            path: [field.key],
+        });
+    }
+    return normalizeCompiledRuntimeSchemaValue(field.compiledSchema, input, {
+        path: [field.key],
+        errorCode: 'invalid-search',
+        missingCode: 'missing-search',
+    });
+}
+function normalizeManySearchBuildValue(field, input) {
+    if (input === undefined || input === null) {
+        if (field.presence === 'optional') {
+            return undefined;
+        }
+        if (field.presence === 'defaulted') {
+            return copyArrayDefault(field);
+        }
+        if (input === null) {
+            throw new UrlKitError('invalid-search', 'Required search parameter cannot be null.', {
+                path: [field.key],
+            });
+        }
+        throw new UrlKitError('missing-search', 'Required search parameter is missing.', {
+            path: [field.key],
+        });
+    }
+    if (!Array.isArray(input)) {
+        throw new UrlKitError('invalid-search', 'Expected an array search parameter value.', {
+            path: [field.key],
+        });
+    }
+    return Object.freeze(input.map((item) => normalizeCompiledRuntimeSchemaValue(field.compiledSchema, item, {
+        path: [field.key],
+        errorCode: 'invalid-search',
+        missingCode: 'missing-search',
+    })));
+}
+function copyArrayDefault(field) {
+    const value = field.defaultValue;
+    if (!Array.isArray(value)) {
+        return Object.freeze([]);
+    }
+    return Object.freeze([...value]);
+}
+
+function serializeSearchBuildValue(field, normalized) {
+    if (isRuntimeSchemaKind(field.schema, 'array')) {
+        return serializeArrayRuntimeSchemaValue(field.schema, normalized, {
+            path: [field.key],
+            errorCode: 'invalid-search',
+        });
+    }
+    if (isRuntimeSchemaKind(field.schema, 'object')) {
+        return undefined;
+    }
+    if (field.type === 'many') {
+        if (!Array.isArray(normalized) || !normalized.length) {
+            return undefined;
+        }
+        return Object.freeze(normalized.map((item) => serializeOneSearchBuildValue(field, item)));
+    }
+    return serializeOneSearchBuildValue(field, normalized);
+}
+function serializeOneSearchBuildValue(field, value) {
+    const serialized = serializeCompiledRuntimeSchemaValue(field.compiledSchema, value, {
+        path: [field.key],
+        errorCode: 'invalid-search',
+        missingCode: 'missing-search',
+    });
+    return serialized ?? '';
+}
+
+function serializeSearchEntries(entries, options = {}) {
+    if (!entries.length) {
+        return '';
+    }
+    const orderedEntries = options.sortKeys ? [...entries].sort(compareSearchEntryKeys) : entries;
+    const searchParams = new URLSearchParams();
+    for (const entry of orderedEntries) {
+        searchParams.append(entry.key, entry.value);
+    }
+    const search = searchParams.toString();
+    return search ? `?${search}` : '';
+}
+function compareSearchEntryKeys(left, right) {
+    return left.key.localeCompare(right.key);
+}
+
+function buildCompiledSearch(input = {}, compiled, options = {}) {
+    const entries = [];
+    for (const field of compiled.fields) {
+        const normalized = normalizeSearchBuildValue(field, input[field.key]);
+        if (normalized === undefined || shouldOmitDefault(field.defaultValue, normalized, options)) {
+            continue;
+        }
+        if (isRuntimeSchemaKind(field.schema, 'object')) {
+            appendObjectSearchEntries(entries, field.key, field.schema, normalized, options);
+            continue;
+        }
+        appendSearchEntry(entries, field.key, serializeSearchBuildValue(field, normalized), options);
+    }
+    return serializeSearchEntries(entries, options);
+}
+function shouldOmitDefault(defaultValue, normalized, options) {
+    return (options.defaults === 'omit' &&
+        defaultValue !== undefined &&
+        areSearchValuesEqual(normalized, defaultValue));
+}
+
+function appendRawSearchValue(output, key, value) {
+    const current = output[key];
+    if (current === undefined) {
+        output[key] = value;
+        return;
+    }
+    output[key] = Object.freeze(Array.isArray(current) ? [...current, value] : [current, value]);
+}
+
+function createSearchParams(input) {
+    if (input instanceof URLSearchParams) {
+        return new URLSearchParams(input);
+    }
+    return new URLSearchParams(input.startsWith('?') ? input.slice(1) : input);
+}
+
+function parseRawSearch(input) {
+    const output = {};
+    for (const [key, value] of createSearchParams(input)) {
+        appendRawSearchValue(output, key, value);
+    }
+    return Object.freeze(output);
+}
+
+function copyRawSearchParams(input) {
+    const output = {};
+    for (const [key, value] of Object.entries(input)) {
+        output[key] = Array.isArray(value) ? Object.freeze([...value]) : value;
+    }
+    return Object.freeze(output);
+}
+
+function collectObjectSearchPaths(schema) {
+    return Object.freeze(collectObjectSearchPathsFromShape(schema, []));
+}
+function collectObjectSearchPathsFromShape(schema, basePath) {
+    const shape = getObjectSchemaShape(schema);
+    const paths = [];
+    for (const [key, childSchema] of Object.entries(shape)) {
+        const childPath = [...basePath, key];
+        if (isRuntimeSchemaKind(childSchema, 'object')) {
+            paths.push(...collectObjectSearchPathsFromShape(childSchema, childPath));
+            continue;
+        }
+        paths.push(Object.freeze(childPath));
+    }
+    return paths;
+}
+
+function getObjectSearchRawKeyPath(parentKey, rawKey) {
+    const prefix = `${parentKey}.`;
+    if (!rawKey.startsWith(prefix)) {
+        return undefined;
+    }
+    const childKey = rawKey.slice(prefix.length);
+    if (!childKey) {
+        return undefined;
+    }
+    return splitObjectSearchKey(childKey);
+}
+
+function createObjectSearchPathKey(path) {
+    return JSON.stringify(path);
+}
+function isObjectSearchPathEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((value, index) => value === right[index]);
+}
+
+function deleteSearchFieldRawKeys(field, rawSearch) {
+    if (isRuntimeSchemaKind(field.schema, 'object')) {
+        deleteObjectSearchKeys(field, rawSearch);
+        return;
+    }
+    delete rawSearch[field.key];
+}
+function deleteObjectSearchKeys(field, rawSearch) {
+    const declaredPaths = collectObjectSearchPaths(field.schema);
+    for (const rawKey of Object.keys(rawSearch)) {
+        const rawPath = getObjectSearchRawKeyPath(field.key, rawKey);
+        if (rawPath &&
+            declaredPaths.some((declaredPath) => isObjectSearchPathEqual(rawPath, declaredPath))) {
+            delete rawSearch[rawKey];
+        }
+    }
+}
+
+function readArraySearchValues(value, arrayFormat = 'repeat') {
+    if (value === undefined) {
+        return undefined;
+    }
+    const values = Array.isArray(value) ? value : [value];
+    if (arrayFormat !== 'comma') {
+        return values;
+    }
+    return Object.freeze(values.flatMap((item) => item.split(',')));
+}
+
+function parseArraySearchValue(schema, value, context, options = {}) {
+    if (value === undefined) {
+        return parseRuntimeSchemaValue(schema, undefined, {
+            path: context.path,
+            errorCode: context.errorCode,
+            missingCode: 'missing-search',
+        });
+    }
+    compileRuntimeSchema(schema, { path: context.path });
+    return parseArrayRuntimeSchemaValue(schema, readArraySearchValues(value, options.arrayFormat) ?? [], context);
+}
+
+function assertNoObjectSearchCollisions(parentKey, rawSearch, parentPath) {
+    const paths = new Map();
+    for (const rawKey of Object.keys(rawSearch)) {
+        const path = getObjectSearchRawKeyPath(parentKey, rawKey);
+        if (!path) {
+            continue;
+        }
+        const pathKey = createObjectSearchPathKey(path);
+        const current = paths.get(pathKey);
+        if (!current) {
+            paths.set(pathKey, { path, rawKeys: new Set([rawKey]) });
+            continue;
+        }
+        current.rawKeys.add(rawKey);
+        if (current.rawKeys.size > 1) {
+            throw new UrlKitError('invalid-search', 'Object search parameter keys resolve to the same object path.', {
+                path: [...parentPath, ...current.path],
+            });
+        }
+    }
+}
+
+function findObjectSearchRawValue(parentKey, path, rawSearch) {
+    for (const [rawKey, value] of Object.entries(rawSearch)) {
+        const rawPath = getObjectSearchRawKeyPath(parentKey, rawKey);
+        if (rawPath && isObjectSearchPathEqual(rawPath, path)) {
+            return value;
+        }
+    }
+    return undefined;
+}
+
+function parseObjectSearchValue(schema, parentKey, rawSearch, context, options = {}) {
+    assertNoObjectSearchCollisions(parentKey, rawSearch, context.path);
+    const descriptor = compileRuntimeSchema(schema, { path: context.path });
+    const hasDeclaredValues = hasDeclaredObjectValues(schema, parentKey, [], rawSearch);
+    if (!hasDeclaredValues) {
+        if (descriptor.presence === 'optional') {
+            return undefined;
+        }
+        if (descriptor.presence === 'defaulted') {
+            return descriptor.defaultValue;
+        }
+    }
+    return parseObjectShape(schema, parentKey, [], rawSearch, context, options);
+}
+function parseObjectShape(schema, parentKey, objectPath, rawSearch, context, options) {
+    const shape = getObjectSchemaShape(schema);
+    const output = {};
+    for (const [key, childSchema] of Object.entries(shape)) {
+        const childObjectPath = [...objectPath, key];
+        const childPath = [...context.path, key];
+        const value = parseChildObjectSearchValue(childSchema, parentKey, childObjectPath, rawSearch, {
+            path: childPath,
+            errorCode: context.errorCode,
+        }, options);
+        if (value !== undefined) {
+            output[key] = value;
+        }
+    }
+    return Object.freeze(output);
+}
+function parseChildObjectSearchValue(schema, parentKey, objectPath, rawSearch, context, options) {
+    if (isRuntimeSchemaKind(schema, 'object')) {
+        return parseNestedObjectSearchValue(schema, parentKey, objectPath, rawSearch, context, options);
+    }
+    const rawValue = findObjectSearchRawValue(parentKey, objectPath, rawSearch);
+    if (isRuntimeSchemaKind(schema, 'array')) {
+        return parseArraySearchValue(schema, rawValue, context, options);
+    }
+    if (Array.isArray(rawValue)) {
+        throw new UrlKitError('invalid-search', 'Expected a single object search parameter value.', {
+            path: context.path,
+        });
+    }
+    return parseRuntimeSchemaValue(schema, rawValue, {
+        path: context.path,
+        errorCode: context.errorCode,
+        missingCode: 'missing-search',
+    });
+}
+function parseNestedObjectSearchValue(schema, parentKey, objectPath, rawSearch, context, options) {
+    const descriptor = compileRuntimeSchema(schema, { path: context.path });
+    const hasDeclaredValues = hasDeclaredObjectValues(schema, parentKey, objectPath, rawSearch);
+    if (!hasDeclaredValues) {
+        if (descriptor.presence === 'optional') {
+            return undefined;
+        }
+        if (descriptor.presence === 'defaulted') {
+            return descriptor.defaultValue;
+        }
+    }
+    return parseObjectShape(schema, parentKey, objectPath, rawSearch, context, options);
+}
+function hasDeclaredObjectValues(schema, parentKey, objectPath, rawSearch) {
+    const shape = getObjectSchemaShape(schema);
+    return Object.entries(shape).some(([key, childSchema]) => {
+        const childObjectPath = [...objectPath, key];
+        if (isRuntimeSchemaKind(childSchema, 'object')) {
+            return hasDeclaredObjectValues(childSchema, parentKey, childObjectPath, rawSearch);
+        }
+        return findObjectSearchRawValue(parentKey, childObjectPath, rawSearch) !== undefined;
+    });
+}
+
+function parseSearchFieldValue(field, rawSearch, options = {}) {
+    if (isRuntimeSchemaKind(field.schema, 'object')) {
+        return parseObjectSearchValue(field.schema, field.key, rawSearch, {
+            path: [field.key],
+            errorCode: 'invalid-search',
+        }, options);
+    }
+    if (isRuntimeSchemaKind(field.schema, 'array')) {
+        return parseArraySearchValue(field.schema, rawSearch[field.key], {
+            path: [field.key],
+            errorCode: 'invalid-search',
+        }, options);
+    }
+    return parseNonObjectSearchFieldValue(field, rawSearch[field.key], options);
+}
+function parseNonObjectSearchFieldValue(field, value, options) {
+    if (value === undefined) {
+        return parseMissingSearchFieldValue(field);
+    }
+    if (field.type === 'many') {
+        const values = readArraySearchValues(value, options.arrayFormat) ?? [];
+        return Object.freeze(values.map((item) => parseRuntimeSearchValue(field, item)));
+    }
+    if (Array.isArray(value)) {
+        throw new UrlKitError('invalid-search', 'Expected a single search parameter value.', {
+            path: [field.key],
+        });
+    }
+    return parseRuntimeSearchValue(field, value);
+}
+function parseMissingSearchFieldValue(field) {
+    if (field.presence === 'optional') {
+        return undefined;
+    }
+    if (field.presence === 'defaulted') {
+        return copyDefaultValue(field.defaultValue);
+    }
+    throw new UrlKitError('missing-search', 'Required search parameter is missing.', {
+        path: [field.key],
+    });
+}
+function parseRuntimeSearchValue(field, value) {
+    return parseCompiledRuntimeSchemaValue(field.compiledSchema, value, {
+        path: [field.key],
+        errorCode: 'invalid-search',
+        missingCode: 'missing-search',
+    });
+}
+function copyDefaultValue(value) {
+    if (Array.isArray(value)) {
+        return Object.freeze([...value]);
+    }
+    if (isPlainObject(value)) {
+        return Object.freeze({ ...value });
+    }
+    return value;
+}
+function isPlainObject(input) {
+    return (typeof input === 'object' && input !== null && !Array.isArray(input) && !(input instanceof Date));
+}
+
+function parseCompiledSearch(rawSearch, compiled, unknownSearch = 'strip', options = {}) {
+    const remainingUnknown = { ...rawSearch };
+    const search = {};
+    for (const field of compiled.fields) {
+        const value = parseSearchFieldValue(field, rawSearch, options);
+        deleteSearchFieldRawKeys(field, remainingUnknown);
+        if (value !== undefined) {
+            search[field.key] = value;
+        }
+    }
+    const result = {
+        search: Object.freeze(search),
+    };
+    const unknown = resolveUnknownSearch$1(remainingUnknown, unknownSearch);
+    if (unknown) {
+        return Object.freeze({
+            ...result,
+            unknownSearch: unknown,
+        });
+    }
+    return Object.freeze(result);
+}
+function resolveUnknownSearch$1(unknown, behavior) {
+    const keys = Object.keys(unknown);
+    if (!keys.length || behavior === 'strip') {
+        return undefined;
+    }
+    if (behavior === 'error') {
+        throw new UrlKitError('invalid-search', 'Unknown search parameter is not allowed.', {
+            path: [keys[0]],
+        });
+    }
+    return copyRawSearchParams(unknown);
+}
+
+function copyUnknownStructuredSearch(input) {
+    const output = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        if (typeof value === 'string') {
+            output[key] = value;
+            continue;
+        }
+        if (Array.isArray(value) && value.every((item) => typeof item === 'string')) {
+            output[key] = Object.freeze([...value]);
+            continue;
+        }
+        throw new UrlKitError('invalid-search', 'Unknown search parameter must be a string or string array to preserve.', {
+            path: [key],
+        });
+    }
+    if (!Object.keys(output).length) {
+        return undefined;
+    }
+    return Object.freeze(output);
+}
+
+function normalizeCompiledSearch(input, compiled, unknownSearch = 'strip') {
+    if (input === undefined || input === null) {
+        return normalizeCompiledSearchObject({}, compiled, unknownSearch);
+    }
+    if (!isRecord$3(input)) {
+        throw new UrlKitError('invalid-search', 'Search must be an object.', { path: ['search'] });
+    }
+    return normalizeCompiledSearchObject(input, compiled, unknownSearch);
+}
+function normalizeCompiledSearchObject(input, compiled, unknownSearch) {
+    const search = {};
+    const knownKeys = compiled?.keys ?? emptyKeys;
+    for (const field of compiled?.fields ?? []) {
+        const value = normalizeSearchBuildValue(field, input[field.key]);
+        if (value !== undefined) {
+            search[field.key] = value;
+        }
+    }
+    const unknownValues = collectUnknownValues(input, knownKeys);
+    const unknown = resolveUnknownSearch(unknownValues, unknownSearch);
+    return Object.freeze({
+        search: Object.freeze(search),
+        ...(unknown ? { unknownSearch: unknown } : {}),
+    });
+}
+const emptyKeys = Object.freeze(new Set());
+function collectUnknownValues(input, knownKeys) {
+    const unknown = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (!knownKeys.has(key)) {
+            unknown[key] = value;
+        }
+    }
+    return unknown;
+}
+function resolveUnknownSearch(unknown, behavior) {
+    const keys = Object.keys(unknown);
+    if (!keys.length || behavior === 'strip') {
+        return undefined;
+    }
+    if (behavior === 'error') {
+        throw new UrlKitError('invalid-search', 'Unknown search parameter is not allowed.', {
+            path: [keys[0]],
+        });
+    }
+    return copyUnknownStructuredSearch(unknown);
+}
+function isRecord$3(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}
+
+const URL_STATE_BRAND = Symbol('urlkit.url-state');
+function markUrlState(state) {
+    Object.defineProperty(state, URL_STATE_BRAND, {
+        value: true,
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    });
+    return state;
+}
+function isUrlState(input) {
+    return (typeof input === 'object' &&
+        input !== null &&
+        input[URL_STATE_BRAND] === true);
+}
+
+function normalizeCompiledUrl(input, compiled, unknownSearch) {
+    if (!isRecord$2(input)) {
+        throw new UrlKitError('invalid-url', 'URL state must be an object.', { path: [] });
+    }
+    const pathnameAndParams = normalizePathnameAndParams(input, compiled);
+    const searchResult = normalizeCompiledSearch(input.search, compiled.search, unknownSearch);
+    const hash = normalizeUrlHash(input.hash, compiled);
+    const state = {
+        pathname: pathnameAndParams.pathname,
+        params: pathnameAndParams.params,
+        search: searchResult.search,
+        hash,
+        ...(searchResult.unknownSearch ? { unknownSearch: searchResult.unknownSearch } : {}),
+    };
+    return Object.freeze(markUrlState(state));
+}
+function normalizePathnameAndParams(input, compiled) {
+    if (compiled.mode === 'path') {
+        if (input.pathname !== undefined) {
+            throw new UrlKitError('invalid-url', 'Path-based URL state must not include pathname.', {
+                path: ['pathname'],
+            });
+        }
+        if (!compiled.path) {
+            throw new UrlKitError('invalid-descriptor', 'Path URL descriptor is missing a compiled path.', { path: ['path'] });
+        }
+        const pathname = compiled.path.buildPath(input.params);
+        const params = compiled.path.parsePathname(String(pathname));
+        return Object.freeze({ pathname, params });
+    }
+    if (input.params !== undefined) {
+        throw new UrlKitError('invalid-url', 'Pathless URL state must not include params.', {
+            path: ['params'],
+        });
+    }
+    return Object.freeze({
+        pathname: normalizePathlessPathname(input.pathname),
+        params: Object.freeze({}),
+    });
+}
+function normalizePathlessPathname(pathname) {
+    if (pathname === undefined) {
+        return '';
+    }
+    if (typeof pathname !== 'string') {
+        throw new UrlKitError('invalid-url', 'Pathless pathname must be a string.', {
+            path: ['pathname'],
+        });
+    }
+    return pathname;
+}
+function normalizeUrlHash(input, compiled) {
+    if (compiled.hash) {
+        return compiled.hash.normalize(input);
+    }
+    if (input !== undefined && input !== null) {
+        throw new UrlKitError('invalid-hash', 'Hash is not declared for this URL contract.', {
+            path: ['hash'],
+        });
+    }
+    return undefined;
+}
+function isRecord$2(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}
+
+function buildCompiledUrl(input, compiled, options = {}) {
+    if (!isRecord$1(input)) {
+        throw new UrlKitError('invalid-url', 'URL build input must be an object.', { path: [] });
+    }
+    const pathname = buildUrlPathname(input, compiled);
+    const search = buildUrlSearch(input.search, compiled, options);
+    const hash = buildUrlHash(input.hash, compiled, options);
+    return `${pathname}${search}${hash}`;
+}
+function buildUrlPathname(input, compiled) {
+    if (compiled.mode === 'path') {
+        if (input.pathname !== undefined && !isUrlState(input)) {
+            throw new UrlKitError('invalid-url', 'Path-based URL build input must not include pathname.', { path: ['pathname'] });
+        }
+        if (!compiled.path) {
+            throw new UrlKitError('invalid-descriptor', 'Path URL descriptor is missing a compiled path.', { path: ['path'] });
+        }
+        return compiled.path.buildPath(input.params);
+    }
+    if (input.params !== undefined && !isUrlState(input)) {
+        throw new UrlKitError('invalid-url', 'Pathless URL build input must not include params.', {
+            path: ['params'],
+        });
+    }
+    if (input.pathname === undefined) {
+        return '';
+    }
+    if (typeof input.pathname !== 'string') {
+        throw new UrlKitError('invalid-url', 'Pathless pathname must be a string.', {
+            path: ['pathname'],
+        });
+    }
+    return input.pathname;
+}
+function buildUrlSearch(input, compiled, options) {
+    if (input === undefined) {
+        return compiled.search ? buildCompiledSearch({}, compiled.search, options) : '';
+    }
+    if (!isRecord$1(input)) {
+        throw new UrlKitError('invalid-search', 'URL search input must be an object.', {
+            path: ['search'],
+        });
+    }
+    if (!compiled.search) {
+        return '';
+    }
+    return buildCompiledSearch(input, compiled.search, options);
+}
+function buildUrlHash(input, compiled, options) {
+    if (compiled.hash) {
+        return buildHash(input, compiled.hash.descriptor, options);
+    }
+    if (input !== undefined && input !== null) {
+        throw new UrlKitError('invalid-hash', 'Hash is not declared for this URL contract.', {
+            path: ['hash'],
+        });
+    }
+    return '';
+}
+function isRecord$1(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}
+
+const URLKIT_BASE_URL = 'http://urlkit.local';
+function parseUrl(input) {
+    if (input instanceof URL) {
+        return freezeParsedUrlInput(input);
+    }
+    if (typeof input !== 'string') {
+        throw new UrlKitError('invalid-url', 'URL input must be a string or URL.', { path: [] });
+    }
+    try {
+        return freezeParsedUrlInput(new URL(input, URLKIT_BASE_URL));
+    }
+    catch (error) {
+        throw new UrlKitError('invalid-url', 'URL input is not valid.', { path: [], cause: error });
+    }
+}
+function freezeParsedUrlInput(input) {
+    return Object.freeze({
+        pathname: input.pathname,
+        searchParams: new URLSearchParams(input.searchParams),
+        hash: input.hash,
+    });
+}
+
+function resolveUrlUnknownSearch(rawSearch, behavior) {
+    const keys = Object.keys(rawSearch);
+    if (!keys.length || behavior === 'strip') {
+        return undefined;
+    }
+    if (behavior === 'error') {
+        throw new UrlKitError('invalid-search', 'Unknown search parameter is not allowed.', {
+            path: [keys[0]],
+        });
+    }
+    return copyRawSearchParams(rawSearch);
+}
+
+function parseCompiledUrl(input, compiled, unknownSearch, options = {}) {
+    const parsedUrl = parseUrl(input);
+    const params = parseUrlParams(parsedUrl.pathname, compiled);
+    const searchResult = parseUrlSearch(parsedUrl.searchParams, compiled, unknownSearch, options);
+    const hash = parseUrlHash(parsedUrl.hash, compiled);
+    const state = {
+        pathname: parsedUrl.pathname,
+        params,
+        search: searchResult.search,
+        hash,
+        ...(searchResult.unknownSearch ? { unknownSearch: searchResult.unknownSearch } : {}),
+    };
+    return Object.freeze(markUrlState(state));
+}
+function parseUrlParams(pathname, compiled) {
+    if (compiled.mode === 'path' && compiled.path) {
+        return compiled.path.parsePathname(pathname);
+    }
+    return Object.freeze({});
+}
+function parseUrlSearch(searchParams, compiled, unknownSearch, options) {
+    const rawSearch = parseRawSearch(searchParams);
+    if (compiled.search) {
+        return parseCompiledSearch(rawSearch, compiled.search, unknownSearch, options);
+    }
+    const unknown = resolveUrlUnknownSearch(rawSearch, unknownSearch);
+    return Object.freeze({
+        search: Object.freeze({}),
+        ...(unknown ? { unknownSearch: unknown } : {}),
+    });
+}
+function parseUrlHash(hash, compiled) {
+    if (!compiled.hash) {
+        return undefined;
+    }
+    return compiled.hash.parse(readHashFragment(hash));
+}
+
+function resolveRequestUrlInput(input, options = {}) {
+    const url = readRequestUrl(input);
+    if (options.baseUrl) {
+        return resolveRequestUrl(url, options.baseUrl);
+    }
+    return url;
+}
+function readRequestUrl(input) {
+    if (isRequest(input)) {
+        return input.url;
+    }
+    if (isUrlRequestInput(input)) {
+        return input.url;
+    }
+    throw new UrlKitError('invalid-url', 'Request input must be a Request or an object with a url string.', {
+        path: [],
+    });
+}
+function resolveRequestUrl(url, baseUrl) {
+    try {
+        return new URL(url, baseUrl);
+    }
+    catch (error) {
+        throw new UrlKitError('invalid-url', 'Request URL is not valid.', {
+            path: [],
+            cause: error,
+        });
+    }
+}
+function isRequest(input) {
+    return typeof Request !== 'undefined' && input instanceof Request;
+}
+function isUrlRequestInput(input) {
+    return (typeof input === 'object' &&
+        input !== null &&
+        'url' in input &&
+        typeof input.url === 'string');
+}
+
+function matchCompiledUrl(input, compiled, unknownSearch, options = {}) {
+    try {
+        parseCompiledUrl(input, compiled, unknownSearch, options);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof UrlKitError) {
+            return false;
+        }
+        return false;
+    }
+}
+
+function buildRawSearch(input = {}, options = {}) {
+    const entries = [];
+    for (const [key, value] of Object.entries(input)) {
+        appendRawValue(entries, key, value, options);
+    }
+    return serializeSearchEntries(entries, options);
+}
+function appendRawValue(entries, key, value, options) {
+    if (value === undefined || value === null) {
+        return;
+    }
+    if (Array.isArray(value)) {
+        appendSearchEntry(entries, key, value.filter(isPresent$1).map(String), options);
+        return;
+    }
+    appendSearchEntry(entries, key, serializeRawScalar(value), options);
+}
+function isPresent$1(input) {
+    return input !== undefined && input !== null;
+}
+function serializeRawScalar(input) {
+    if (typeof input === 'string') {
+        return input;
+    }
+    if (typeof input === 'number' || typeof input === 'boolean' || typeof input === 'bigint') {
+        return String(input);
+    }
+    return JSON.stringify(input) ?? String(input);
+}
+
+function omitRawSearch(input, keys) {
+    const keySet = new Set(keys);
+    const output = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (keySet.has(key)) {
+            continue;
+        }
+        output[key] = copyRawSearchValue(value);
+    }
+    return Object.freeze(output);
+}
+function pickRawSearch(input, keys) {
+    const keySet = new Set(keys);
+    const output = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (!keySet.has(key)) {
+            continue;
+        }
+        output[key] = copyRawSearchValue(value);
+    }
+    return Object.freeze(output);
+}
+function copyRawSearchValue(value) {
+    return Array.isArray(value) ? Object.freeze([...value]) : value;
+}
+
+function formatParsedUrl(input, search) {
+    return `${input.pathname}${search}${input.hash}`;
+}
+
+function omitCompiledUrlSearch(input, keys, _compiled, options = {}) {
+    const parsed = parseUrl(input);
+    const filtered = omitRawSearch(parseRawSearch(parsed.searchParams), keys);
+    return formatParsedUrl(parsed, buildRawSearch(filtered, options));
+}
+function pickCompiledUrlSearch(input, keys, _compiled, options = {}) {
+    const parsed = parseUrl(input);
+    const filtered = pickRawSearch(parseRawSearch(parsed.searchParams), keys);
+    return formatParsedUrl(parsed, buildRawSearch(filtered, options));
+}
+
+function joinSearchStrings(...parts) {
+    const body = parts
+        .map((part) => part.replace(/^\?/, ''))
+        .filter(Boolean)
+        .join('&');
+    return body ? `?${body}` : '';
+}
+
+function hasSearchFieldRawValue(field, rawSearch) {
+    if (isRuntimeSchemaKind(field.schema, 'object')) {
+        return hasObjectRawValue(field.schema, field.key, rawSearch);
+    }
+    return rawSearch[field.key] !== undefined;
+}
+function hasObjectRawValue(schema, parentKey, rawSearch) {
+    const shape = getObjectSchemaShape(schema);
+    return Object.entries(shape).some(([key, childSchema]) => {
+        const childSearchKey = joinObjectSearchKey(parentKey, key);
+        if (isRuntimeSchemaKind(childSchema, 'object')) {
+            return hasObjectRawValue(childSchema, childSearchKey, rawSearch);
+        }
+        return rawSearch[childSearchKey] !== undefined;
+    });
+}
+
+function parsePartialCompiledSearch(rawSearch, compiled, options = {}) {
+    const remainingUnknown = { ...rawSearch };
+    const search = {};
+    for (const field of compiled.fields) {
+        if (!hasSearchFieldRawValue(field, rawSearch)) {
+            continue;
+        }
+        const value = parseSearchFieldValue(field, rawSearch, options);
+        deleteSearchFieldRawKeys(field, remainingUnknown);
+        if (value !== undefined) {
+            search[field.key] = value;
+        }
+    }
+    return Object.freeze({
+        search: Object.freeze(search),
+        unknownSearch: copyRawSearchParams(remainingUnknown),
+    });
+}
+
+function patchCompiledUrlSearch(input, patch, compiled, options = {}) {
+    const parsed = parseUrl(input);
+    const rawSearch = parseRawSearch(parsed.searchParams);
+    if (!compiled.search) {
+        return formatParsedUrl(parsed, buildRawPatchSearch(rawSearch, patch, options));
+    }
+    const currentParsed = parsePartialCompiledSearch(rawSearch, compiled.search, options);
+    const mergedSearch = { ...currentParsed.search };
+    const unknownSearch = {
+        ...copyRawSearchParams(currentParsed.unknownSearch),
+    };
+    const schemaKeys = compiled.search.keys;
+    for (const [key, value] of Object.entries(patch)) {
+        if (shouldRemoveUndefined(value, options) || shouldRemoveNull(value, options)) {
+            delete mergedSearch[key];
+            delete unknownSearch[key];
+            continue;
+        }
+        if (value === undefined || value === null) {
+            continue;
+        }
+        if (schemaKeys.has(key)) {
+            mergedSearch[key] = value;
+        }
+    }
+    const search = joinSearchStrings(buildCompiledSearch(mergedSearch, compiled.search, options), buildRawSearch(unknownSearch, options));
+    return formatParsedUrl(parsed, search);
+}
+function buildRawPatchSearch(rawSearch, patch, options) {
+    const merged = { ...rawSearch };
+    for (const [key, value] of Object.entries(patch)) {
+        if (shouldRemoveUndefined(value, options) || shouldRemoveNull(value, options)) {
+            delete merged[key];
+            continue;
+        }
+        if (value === undefined || value === null) {
+            continue;
+        }
+        merged[key] = toRawSearchValue(value);
+    }
+    return buildRawSearch(merged, options);
+}
+function shouldRemoveUndefined(value, options) {
+    return value === undefined && options.removeUndefined === true;
+}
+function shouldRemoveNull(value, options) {
+    return value === null && options.removeNull === true;
+}
+function toRawSearchValue(value) {
+    if (Array.isArray(value)) {
+        return Object.freeze(value.filter(isPresent).map(String));
+    }
+    return String(value);
+}
+function isPresent(value) {
+    return value !== undefined && value !== null;
+}
+
+function replaceCompiledUrlSearch(input, next, compiled, options = {}) {
+    const parsed = parseUrl(input);
+    const search = compiled.search
+        ? buildCompiledSearch(next, compiled.search, options)
+        : buildRawSearch(next, options);
+    return formatParsedUrl(parsed, search);
+}
+
+function compileUrlDescriptor(descriptor) {
+    assertNormalizedUrlDescriptor(descriptor);
+    const path = compileUrlPath(descriptor);
+    const search = descriptor.search ? compileSearchSchema(descriptor.search) : undefined;
+    const hash = descriptor.hash ? compileHashDescriptor(descriptor.hash) : undefined;
+    return Object.freeze({
+        mode: descriptor.mode,
+        pattern: descriptor.pattern,
+        path,
+        ...(descriptor.search ? { searchSchema: descriptor.search, search } : {}),
+        ...(hash ? { hash } : {}),
+    });
+}
+function compileUrlPath(descriptor) {
+    if (descriptor.mode === 'path') {
+        if (descriptor.path) {
+            return descriptor.path;
+        }
+        if (typeof descriptor.pattern === 'string') {
+            return compilePath(descriptor.pattern);
+        }
+        throw new UrlKitError('invalid-descriptor', 'Path URL descriptor must include a path pattern.', { path: ['path'] });
+    }
+    return undefined;
+}
+function assertNormalizedUrlDescriptor(input) {
+    if (!isRecord(input)) {
+        throw new UrlKitError('invalid-descriptor', 'URL descriptor must be an object.', { path: [] });
+    }
+    if (input.mode !== 'path' && input.mode !== 'pathless') {
+        throw new UrlKitError('invalid-descriptor', 'URL descriptor mode must be path or pathless.', {
+            path: ['mode'],
+        });
+    }
+    if (input.mode === 'path' && typeof input.pattern !== 'string') {
+        throw new UrlKitError('invalid-descriptor', 'Path URL descriptor pattern must be a string.', {
+            path: ['pattern'],
+        });
+    }
+    if (input.mode === 'pathless' && input.pattern !== undefined) {
+        throw new UrlKitError('invalid-descriptor', 'Pathless URL descriptor pattern must be undefined.', { path: ['pattern'] });
+    }
+}
+function isRecord(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}
+
+function createUrlContract(descriptor, options = {}) {
+    const compiled = compileUrlDescriptor(descriptor);
+    const unknownSearch = options.unknownSearch ?? 'strip';
+    const arrayFormat = options.arrayFormat ?? 'repeat';
+    const contract = {
+        pattern: compiled.pattern,
+        parse(input, options) {
+            return parseCompiledUrl(input, compiled, options?.unknownSearch ?? unknownSearch, { arrayFormat: options?.arrayFormat ?? arrayFormat });
+        },
+        safeParse(input, options) {
+            try {
+                return Object.freeze({
+                    success: true,
+                    data: parseCompiledUrl(input, compiled, options?.unknownSearch ?? unknownSearch, { arrayFormat: options?.arrayFormat ?? arrayFormat }),
+                });
+            }
+            catch (error) {
+                return Object.freeze({
+                    success: false,
+                    error: error instanceof UrlKitError ? error : new UrlKitError('invalid-url', { cause: error }),
+                });
+            }
+        },
+        parseRequest(input, options) {
+            return parseCompiledUrl(resolveRequestUrlInput(input, options), compiled, options?.unknownSearch ?? unknownSearch, { arrayFormat: options?.arrayFormat ?? arrayFormat });
+        },
+        safeParseRequest(input, options) {
+            try {
+                return Object.freeze({
+                    success: true,
+                    data: parseCompiledUrl(resolveRequestUrlInput(input, options), compiled, options?.unknownSearch ?? unknownSearch, { arrayFormat: options?.arrayFormat ?? arrayFormat }),
+                });
+            }
+            catch (error) {
+                return Object.freeze({
+                    success: false,
+                    error: error instanceof UrlKitError ? error : new UrlKitError('invalid-url', { cause: error }),
+                });
+            }
+        },
+        normalize(input, options) {
+            return normalizeCompiledUrl(input, compiled, options?.unknownSearch ?? unknownSearch);
+        },
+        safeNormalize(input, options) {
+            try {
+                return Object.freeze({
+                    success: true,
+                    data: normalizeCompiledUrl(input, compiled, options?.unknownSearch ?? unknownSearch),
+                });
+            }
+            catch (error) {
+                return Object.freeze({
+                    success: false,
+                    error: error instanceof UrlKitError ? error : new UrlKitError('invalid-url', { cause: error }),
+                });
+            }
+        },
+        build(input, options) {
+            return buildCompiledUrl(input, compiled, mergeBuildOptions(arrayFormat, options));
+        },
+        match(input, options) {
+            return matchCompiledUrl(input, compiled, options?.unknownSearch ?? unknownSearch, {
+                arrayFormat: options?.arrayFormat ?? arrayFormat,
+            });
+        },
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        parsePathname: compiled.path?.parsePathname,
+        buildPath: compiled.path?.buildPath,
+        parseSearch(input, options) {
+            if (compiled.search) {
+                return parseCompiledSearch(parseRawSearch(input), compiled.search, options?.unknownSearch ?? unknownSearch, { arrayFormat: options?.arrayFormat ?? arrayFormat }).search;
+            }
+            return Object.freeze({});
+        },
+        parseHash(input) {
+            return compiled.hash
+                ? parseHash(input, compiled.hash.descriptor)
+                : parseHash(input);
+        },
+        buildSearch(search, options) {
+            if (compiled.search) {
+                return buildCompiledSearch(search, compiled.search, mergeBuildOptions(arrayFormat, options));
+            }
+            return '';
+        },
+        buildHash(hash, options) {
+            return compiled.hash
+                ? buildHash(hash, compiled.hash.descriptor, options)
+                : buildHash(hash, options);
+        },
+        withSearch(input, search, options) {
+            return patchCompiledUrlSearch(input, search, compiled, mergeBuildOptions(arrayFormat, options));
+        },
+        replaceSearch(input, search, options) {
+            return replaceCompiledUrlSearch(input, search, compiled, mergeBuildOptions(arrayFormat, options));
+        },
+        omitSearch(input, keys, options) {
+            return omitCompiledUrlSearch(input, keys, compiled, mergeBuildOptions(arrayFormat, options));
+        },
+        pickSearch(input, keys, options) {
+            return pickCompiledUrlSearch(input, keys, compiled, mergeBuildOptions(arrayFormat, options));
+        },
+    };
+    return Object.freeze(contract);
+}
+function mergeBuildOptions(arrayFormat, options) {
+    return {
+        ...options,
+        arrayFormat: options?.arrayFormat ?? arrayFormat,
+    };
+}
+
+export { createUrlContract as a, array as b, compileHashDescriptor as c, buildCompiledSearch as d, buildRawSearch as e, omitRawSearch as f, getObjectSchemaShape as g, parseRawSearch as h, hasSearchFieldRawValue as i, parseSearchFieldValue as j, deleteSearchFieldRawKeys as k, copyRawSearchParams as l, joinSearchStrings as m, pickRawSearch as n, object as o, parseArrayRuntimeSchemaValue as p, parseCompiledSearch as q, readHashFragment as r, serializeArrayRuntimeSchemaValue as s, buildHash as t, parseHash as u };
+//# sourceMappingURL=create-url-contract-BYKPM9bn.js.map