@mionjs/run-types 0.8.10 → 0.13.0

package/dist/go-generated/runTypeKind.generated.d.ts

@@ -0,0 +1,63 @@
+export declare const RunTypeKind: {
+    readonly never: 0;
+    readonly any: 1;
+    readonly unknown: 2;
+    readonly void: 3;
+    readonly object: 4;
+    readonly string: 5;
+    readonly number: 6;
+    readonly boolean: 7;
+    readonly symbol: 8;
+    readonly bigint: 9;
+    readonly null: 10;
+    readonly undefined: 11;
+    readonly regexp: 12;
+    readonly literal: 13;
+    readonly templateLiteral: 14;
+    readonly property: 15;
+    readonly method: 16;
+    readonly function: 17;
+    readonly parameter: 18;
+    readonly promise: 19;
+    readonly class: 20;
+    readonly typeParameter: 21;
+    readonly enum: 22;
+    readonly union: 23;
+    readonly intersection: 24;
+    readonly array: 25;
+    readonly tuple: 26;
+    readonly tupleMember: 27;
+    readonly enumMember: 28;
+    readonly rest: 29;
+    readonly objectLiteral: 30;
+    readonly indexSignature: 31;
+    readonly propertySignature: 32;
+    readonly methodSignature: 33;
+    readonly infer: 34;
+    readonly callSignature: 35;
+    readonly ref: -1;
+};
+export type RunTypeKindName = keyof typeof RunTypeKind;
+export type RunTypeKindValue = (typeof RunTypeKind)[RunTypeKindName];
+export declare const RunTypeSubKind: {
+    readonly none: 0;
+    readonly mapKey: 1801;
+    readonly mapValue: 1802;
+    readonly setItem: 1803;
+    readonly date: 2001;
+    readonly map: 2002;
+    readonly set: 2003;
+    readonly nonSerializable: 2004;
+    readonly url: 2005;
+    readonly temporalInstant: 2101;
+    readonly temporalZonedDateTime: 2102;
+    readonly temporalPlainDate: 2103;
+    readonly temporalPlainTime: 2104;
+    readonly temporalPlainDateTime: 2105;
+    readonly temporalPlainYearMonth: 2106;
+    readonly temporalPlainMonthDay: 2107;
+    readonly temporalDuration: 2108;
+};
+export type RunTypeSubKindName = keyof typeof RunTypeSubKind;
+export type RunTypeSubKindValue = (typeof RunTypeSubKind)[RunTypeSubKindName];
+//# sourceMappingURL=runTypeKind.generated.d.ts.map

package/dist/go-generated/runTypeKind.generated.js

@@ -0,0 +1,59 @@
+export const RunTypeKind = {
+    never: 0,
+    any: 1,
+    unknown: 2,
+    void: 3,
+    object: 4,
+    string: 5,
+    number: 6,
+    boolean: 7,
+    symbol: 8,
+    bigint: 9,
+    null: 10,
+    undefined: 11,
+    regexp: 12,
+    literal: 13,
+    templateLiteral: 14,
+    property: 15,
+    method: 16,
+    function: 17,
+    parameter: 18,
+    promise: 19,
+    class: 20,
+    typeParameter: 21,
+    enum: 22,
+    union: 23,
+    intersection: 24,
+    array: 25,
+    tuple: 26,
+    tupleMember: 27,
+    enumMember: 28,
+    rest: 29,
+    objectLiteral: 30,
+    indexSignature: 31,
+    propertySignature: 32,
+    methodSignature: 33,
+    infer: 34,
+    callSignature: 35,
+    ref: -1,
+};
+export const RunTypeSubKind = {
+    none: 0,
+    mapKey: 1801,
+    mapValue: 1802,
+    setItem: 1803,
+    date: 2001,
+    map: 2002,
+    set: 2003,
+    nonSerializable: 2004,
+    url: 2005,
+    temporalInstant: 2101,
+    temporalZonedDateTime: 2102,
+    temporalPlainDate: 2103,
+    temporalPlainTime: 2104,
+    temporalPlainDateTime: 2105,
+    temporalPlainYearMonth: 2106,
+    temporalPlainMonthDay: 2107,
+    temporalDuration: 2108,
+};
+//# sourceMappingURL=runTypeKind.generated.js.map

package/dist/go-generated/runTypeKind.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runTypeKind.generated.js","sourceRoot":"","sources":["../../src/go-generated/runTypeKind.generated.ts"],"names":[],"mappings":"AAwBA,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,KAAK,EAAE,CAAC;IACR,GAAG,EAAE,CAAC;IACN,OAAO,EAAE,CAAC;IACV,IAAI,EAAE,CAAC;IACP,MAAM,EAAE,CAAC;IACT,MAAM,EAAE,CAAC;IACT,MAAM,EAAE,CAAC;IACT,OAAO,EAAE,CAAC;IACV,MAAM,EAAE,CAAC;IACT,MAAM,EAAE,CAAC;IACT,IAAI,EAAE,EAAE;IACR,SAAS,EAAE,EAAE;IACb,MAAM,EAAE,EAAE;IACV,OAAO,EAAE,EAAE;IACX,eAAe,EAAE,EAAE;IACnB,QAAQ,EAAE,EAAE;IACZ,MAAM,EAAE,EAAE;IACV,QAAQ,EAAE,EAAE;IACZ,SAAS,EAAE,EAAE;IACb,OAAO,EAAE,EAAE;IACX,KAAK,EAAE,EAAE;IACT,aAAa,EAAE,EAAE;IACjB,IAAI,EAAE,EAAE;IACR,KAAK,EAAE,EAAE;IACT,YAAY,EAAE,EAAE;IAChB,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,EAAE;IACT,WAAW,EAAE,EAAE;IACf,UAAU,EAAE,EAAE;IACd,IAAI,EAAE,EAAE;IACR,aAAa,EAAE,EAAE;IACjB,cAAc,EAAE,EAAE;IAClB,iBAAiB,EAAE,EAAE;IACrB,eAAe,EAAE,EAAE;IACnB,KAAK,EAAE,EAAE;IACT,aAAa,EAAE,EAAE;IACjB,GAAG,EAAE,CAAC,CAAC;CACC,CAAC;AAKX,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,CAAC;IACP,MAAM,EAAE,IAAI;IACZ,QAAQ,EAAE,IAAI;IACd,OAAO,EAAE,IAAI;IACb,IAAI,EAAE,IAAI;IACV,GAAG,EAAE,IAAI;IACT,GAAG,EAAE,IAAI;IACT,eAAe,EAAE,IAAI;IACrB,GAAG,EAAE,IAAI;IACT,eAAe,EAAE,IAAI;IACrB,qBAAqB,EAAE,IAAI;IAC3B,iBAAiB,EAAE,IAAI;IACvB,iBAAiB,EAAE,IAAI;IACvB,qBAAqB,EAAE,IAAI;IAC3B,sBAAsB,EAAE,IAAI;IAC5B,qBAAqB,EAAE,IAAI;IAC3B,gBAAgB,EAAE,IAAI;CACd,CAAC"}

package/dist/go-generated/typeFormats.generated.d.ts

@@ -0,0 +1,105 @@
+import { type RunTypeKindValue } from './runTypeKind.generated.ts';
+export interface TypeFormatMeta {
+    readonly name: FormatName;
+    readonly kind: RunTypeKindValue;
+}
+export declare const typeFormats: {
+    readonly bigintFormat: {
+        readonly name: 'bigintFormat';
+        readonly kind: 9;
+    };
+    readonly creditCard: {
+        readonly name: 'creditCard';
+        readonly kind: 5;
+    };
+    readonly date: {
+        readonly name: 'date';
+        readonly kind: 5;
+    };
+    readonly dateTime: {
+        readonly name: 'dateTime';
+        readonly kind: 5;
+    };
+    readonly domain: {
+        readonly name: 'domain';
+        readonly kind: 5;
+    };
+    readonly email: {
+        readonly name: 'email';
+        readonly kind: 5;
+    };
+    readonly formattedArray: {
+        readonly name: 'formattedArray';
+        readonly kind: 25;
+    };
+    readonly formattedMap: {
+        readonly name: 'formattedMap';
+        readonly kind: 20;
+    };
+    readonly formattedObject: {
+        readonly name: 'formattedObject';
+        readonly kind: 4;
+    };
+    readonly formattedSet: {
+        readonly name: 'formattedSet';
+        readonly kind: 20;
+    };
+    readonly ip: {
+        readonly name: 'ip';
+        readonly kind: 5;
+    };
+    readonly nativeDate: {
+        readonly name: 'nativeDate';
+        readonly kind: 20;
+    };
+    readonly nativeUrl: {
+        readonly name: 'nativeUrl';
+        readonly kind: 20;
+    };
+    readonly numberFormat: {
+        readonly name: 'numberFormat';
+        readonly kind: 6;
+    };
+    readonly stringFormat: {
+        readonly name: 'stringFormat';
+        readonly kind: 5;
+    };
+    readonly temporalInstant: {
+        readonly name: 'temporalInstant';
+        readonly kind: 20;
+    };
+    readonly temporalPlainDate: {
+        readonly name: 'temporalPlainDate';
+        readonly kind: 20;
+    };
+    readonly temporalPlainDateTime: {
+        readonly name: 'temporalPlainDateTime';
+        readonly kind: 20;
+    };
+    readonly temporalPlainTime: {
+        readonly name: 'temporalPlainTime';
+        readonly kind: 20;
+    };
+    readonly temporalPlainYearMonth: {
+        readonly name: 'temporalPlainYearMonth';
+        readonly kind: 20;
+    };
+    readonly temporalZonedDateTime: {
+        readonly name: 'temporalZonedDateTime';
+        readonly kind: 20;
+    };
+    readonly time: {
+        readonly name: 'time';
+        readonly kind: 5;
+    };
+    readonly url: {
+        readonly name: 'url';
+        readonly kind: 5;
+    };
+    readonly uuid: {
+        readonly name: 'uuid';
+        readonly kind: 5;
+    };
+};
+export type FormatName = keyof typeof typeFormats;
+//# sourceMappingURL=typeFormats.generated.d.ts.map

package/dist/go-generated/typeFormats.generated.js

@@ -0,0 +1,28 @@
+import { RunTypeKind } from './runTypeKind.generated.js';
+export const typeFormats = {
+    bigintFormat: { name: 'bigintFormat', kind: RunTypeKind.bigint },
+    creditCard: { name: 'creditCard', kind: RunTypeKind.string },
+    date: { name: 'date', kind: RunTypeKind.string },
+    dateTime: { name: 'dateTime', kind: RunTypeKind.string },
+    domain: { name: 'domain', kind: RunTypeKind.string },
+    email: { name: 'email', kind: RunTypeKind.string },
+    formattedArray: { name: 'formattedArray', kind: RunTypeKind.array },
+    formattedMap: { name: 'formattedMap', kind: RunTypeKind.class },
+    formattedObject: { name: 'formattedObject', kind: RunTypeKind.object },
+    formattedSet: { name: 'formattedSet', kind: RunTypeKind.class },
+    ip: { name: 'ip', kind: RunTypeKind.string },
+    nativeDate: { name: 'nativeDate', kind: RunTypeKind.class },
+    nativeUrl: { name: 'nativeUrl', kind: RunTypeKind.class },
+    numberFormat: { name: 'numberFormat', kind: RunTypeKind.number },
+    stringFormat: { name: 'stringFormat', kind: RunTypeKind.string },
+    temporalInstant: { name: 'temporalInstant', kind: RunTypeKind.class },
+    temporalPlainDate: { name: 'temporalPlainDate', kind: RunTypeKind.class },
+    temporalPlainDateTime: { name: 'temporalPlainDateTime', kind: RunTypeKind.class },
+    temporalPlainTime: { name: 'temporalPlainTime', kind: RunTypeKind.class },
+    temporalPlainYearMonth: { name: 'temporalPlainYearMonth', kind: RunTypeKind.class },
+    temporalZonedDateTime: { name: 'temporalZonedDateTime', kind: RunTypeKind.class },
+    time: { name: 'time', kind: RunTypeKind.string },
+    url: { name: 'url', kind: RunTypeKind.string },
+    uuid: { name: 'uuid', kind: RunTypeKind.string },
+};
+//# sourceMappingURL=typeFormats.generated.js.map

package/dist/go-generated/typeFormats.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeFormats.generated.js","sourceRoot":"","sources":["../../src/go-generated/typeFormats.generated.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAC,WAAW,EAAwB,MAAM,4BAA4B,CAAC;AAU9E,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,YAAY,EAAE,EAAC,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,EAAC;IAC9D,UAAU,EAAE,EAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,EAAC;IAC1D,IAAI,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,EAAC;IAC9C,QAAQ,EAAE,EAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,EAAC;IACtD,MAAM,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,EAAC;IAClD,KAAK,EAAE,EAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,EAAC;IAChD,cAAc,EAAE,EAAC,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,CAAC,KAAK,EAAC;IACjE,YAAY,EAAE,EAAC,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,WAAW,CAAC,KAAK,EAAC;IAC7D,eAAe,EAAE,EAAC,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,EAAC;IACpE,YAAY,EAAE,EAAC,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,WAAW,CAAC,KAAK,EAAC;IAC7D,EAAE,EAAE,EAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,EAAC;IAC1C,UAAU,EAAE,EAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,WAAW,CAAC,KAAK,EAAC;IACzD,SAAS,EAAE,EAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,CAAC,KAAK,EAAC;IACvD,YAAY,EAAE,EAAC,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,EAAC;IAC9D,YAAY,EAAE,EAAC,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,EAAC;IAC9D,eAAe,EAAE,EAAC,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,WAAW,CAAC,KAAK,EAAC;IACnE,iBAAiB,EAAE,EAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,WAAW,CAAC,KAAK,EAAC;IACvE,qBAAqB,EAAE,EAAC,IAAI,EAAE,uBAAuB,EAAE,IAAI,EAAE,WAAW,CAAC,KAAK,EAAC;IAC/E,iBAAiB,EAAE,EAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,WAAW,CAAC,KAAK,EAAC;IACvE,sBAAsB,EAAE,EAAC,IAAI,EAAE,wBAAwB,EAAE,IAAI,EAAE,WAAW,CAAC,KAAK,EAAC;IACjF,qBAAqB,EAAE,EAAC,IAAI,EAAE,uBAAuB,EAAE,IAAI,EAAE,WAAW,CAAC,KAAK,EAAC;IAC/E,IAAI,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,EAAC;IAC9C,GAAG,EAAE,EAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,EAAC;IAC5C,IAAI,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,EAAC;CACtC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+export { type InjectRunTypeId, type InjectTypeFnArgs, type InjectPureFnId, type InjectBatchId, type InjectApiMetadata, type InjectBuildVersion, type CompTimeArgs, type CompTimeFnArgs, type CompTimeHints, type PureFunction, type PureFunctionFactory, getRunTypeId, } from './markers.ts';
+export { getRunType } from './getRunType.ts';
+export { type CompiledFnData, type CompiledTypeFn, type InitializedTypeFn, type CompiledFnArgs, type CompiledPureFunction, type PureFunctionData, type AnyFn, } from './runtypes/types.ts';
+export { type RunType } from './runtypes/types.ts';
+export { type DataOnly } from './runtypes/dataOnly.ts';
+export { type StripRunTypeMeta, type JsonValue } from './runtypes/stripRunTypeMeta.ts';
+export { type JSONShape } from './runtypes/jsonShape.ts';
+export { type InferType, type AnyOf } from './builders/static.ts';
+export { type FriendlyText, type FriendlyNode, type FriendlyMeta, type ErrorTemplates, type FriendlyTemplate, type PluralCategory, type PluralTemplate, type TemplateLeaf, } from './enrich/friendlyText.ts';
+export { type MockData, type MockNode } from './enrich/mockData.ts';
+export { createFriendlyText, createFriendlyTextI18n, resolveLocale, type FriendlyMessage, type FriendlyRenderer, type FriendlyI18nOptions, } from './enrich/createFriendlyText.ts';
+import './runtypes/pure-fns-utils.ts';
+export { type TypeFormat, type TypeFormatBase, type TypeFormatParams, type FormatNameOf, type FormatParamsOf, type FormatBrandNameOf, type FormatBrand, type NominalBrand, } from './runtypes/typeFormat.ts';
+export type { __rtFormatName, __rtFormatParams } from './runtypes/sentinelKeys.ts';
+export type { FormatErrorsOf } from './runtypes/formatErrors.ts';
+export type { InsertModel, SelectModel, UpdateModel } from './modelTypes.ts';
+export { type FormatAnnotation } from './runtypes/formatAnnotation.ts';
+export { registerFormatPattern, type FormatPattern, type StringPatternArgs } from './runtypes/formatPattern.ts';
+export { RunTypeKind, type RunTypeKindName, type RunTypeKindValue, RunTypeSubKind, type RunTypeSubKindName, type RunTypeSubKindValue, } from './go-generated/runTypeKind.generated.ts';
+export { createValidateFn, type ValidateFn, type ValidateOptions, createGetValidationErrorsFn, type GetValidationErrorsFn, type RTValidationError, type TypeFormatError, type RTValidationErrorPathSegment, type RTPathSegment, createRemoveUnknownKeysFn, type RemoveUnknownKeysFn, type RemoveUnknownKeysOptions, createFormatTransformFn, type FormatTransformFn, createJsonEncoderFn, type JsonEncoderFn, type JsonEncoderOptions, type JsonEncoderStrategy, createJsonDecoderFn, type JsonDecoderFn, type JsonDecoderOptions, type JsonDecoderStrategy, createPrepareForJsonFn, type PrepareForJsonFn, type PrepareForJsonOptions, createRestoreFromJsonFn, type RestoreFromJsonFn, type RestoreFromJsonOptions, type JsonValueStrategy, } from './createRTFunctions.ts';
+export { overrideValidate, overrideGetValidationErrors, overrideRemoveUnknownKeys, overrideFormatTransform, overrideJsonEncoder, overrideJsonDecoder, } from './overrideRTFunctions.ts';
+export { createStandardSchema, type RTStandardSchemaV1, type RTValidationResult, type RTValidationFailureResult, } from './standard/createStandardSchema.ts';
+export { runTypeErrorsToIssues, type IssueMappingOptions, type RTValidationIssue } from './standard/issueMapping.ts';
+export { type StandardSchemaV1, type StandardSchemaProps, type StandardSchemaResult, type StandardSchemaSuccessResult, type StandardSchemaFailureResult, type StandardSchemaIssue, type StandardSchemaPathSegment, type StandardSchemaTypes, type StandardSchemaInferInput, type StandardSchemaInferOutput, type StandardJSONSchemaV1, type StandardJSONSchemaProps, type StandardJSONSchemaConverter, type StandardJSONSchemaOptions, } from './standard/spec.ts';
+export { createJsonSchemaFn, type JsonSchemaFn } from './standard/createJsonSchemaFn.ts';
+export { stripDialect, buildJsonSchemaConverter, JSON_SCHEMA_TARGET, JSON_SCHEMA_DIALECT_KEYWORDS, type JsonSchemaDocFn, } from './standard/jsonSchemaDoc.ts';
+export { CircularReferenceError, type CircularPath } from './runtypes/circular.ts';
+export declare const UNSAFE_PROPERTY_NAME_MESSAGE = "[mion] Unsafe property name: ";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,15 @@
+export { getRunTypeId, } from './markers.js';
+export { getRunType } from './getRunType.js';
+export { createFriendlyText, createFriendlyTextI18n, resolveLocale, } from './enrich/createFriendlyText.js';
+import './runtypes/pure-fns-utils.js';
+export { registerFormatPattern } from './runtypes/formatPattern.js';
+export { RunTypeKind, RunTypeSubKind, } from './go-generated/runTypeKind.generated.js';
+export { createValidateFn, createGetValidationErrorsFn, createRemoveUnknownKeysFn, createFormatTransformFn, createJsonEncoderFn, createJsonDecoderFn, createPrepareForJsonFn, createRestoreFromJsonFn, } from './createRTFunctions.js';
+export { overrideValidate, overrideGetValidationErrors, overrideRemoveUnknownKeys, overrideFormatTransform, overrideJsonEncoder, overrideJsonDecoder, } from './overrideRTFunctions.js';
+export { createStandardSchema, } from './standard/createStandardSchema.js';
+export { runTypeErrorsToIssues } from './standard/issueMapping.js';
+export { createJsonSchemaFn } from './standard/createJsonSchemaFn.js';
+export { stripDialect, buildJsonSchemaConverter, JSON_SCHEMA_TARGET, JSON_SCHEMA_DIALECT_KEYWORDS, } from './standard/jsonSchemaDoc.js';
+export { CircularReferenceError } from './runtypes/circular.js';
+export const UNSAFE_PROPERTY_NAME_MESSAGE = '[mion] Unsafe property name: ';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAYL,YAAY,GACb,MAAM,cAAc,CAAC;AAMtB,OAAO,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AA4C3C,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,aAAa,GAId,MAAM,gCAAgC,CAAC;AAIxC,OAAO,8BAA8B,CAAC;AA8BtC,OAAO,EAAC,qBAAqB,EAA6C,MAAM,6BAA6B,CAAC;AAK9G,OAAO,EACL,WAAW,EAGX,cAAc,GAGf,MAAM,yCAAyC,CAAC;AAEjD,OAAO,EAGL,gBAAgB,EAGhB,2BAA2B,EAM3B,yBAAyB,EAGzB,uBAAuB,EAEvB,mBAAmB,EAInB,mBAAmB,EAMnB,sBAAsB,EAGtB,uBAAuB,GAIxB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,gBAAgB,EAChB,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,0BAA0B,CAAC;AAQlC,OAAO,EACL,oBAAoB,GAIrB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAC,qBAAqB,EAAmD,MAAM,4BAA4B,CAAC;AAmBnH,OAAO,EAAC,kBAAkB,EAAoB,MAAM,kCAAkC,CAAC;AACvF,OAAO,EACL,YAAY,EACZ,wBAAwB,EACxB,kBAAkB,EAClB,4BAA4B,GAE7B,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAAC,sBAAsB,EAAoB,MAAM,wBAAwB,CAAC;AAGjF,MAAM,CAAC,MAAM,4BAA4B,GAAG,+BAA+B,CAAC"}

package/dist/markers.d.ts

@@ -0,0 +1,34 @@
+import type { RunType } from './runtypes/types.ts';
+export type InjectRunTypeId<T> = string & {
+    readonly __rtInjectRunTypeIdBrand?: T;
+};
+export type InjectTypeFnArgs<T, F1 extends string, F2 extends string = never, F3 extends string = never, F4 extends string = never, F5 extends string = never, F6 extends string = never, F7 extends string = never, F8 extends string = never, F9 extends string = never, F10 extends string = never, F11 extends string = never, F12 extends string = never> = string & {
+    readonly __rtInjectTypeFnArgsBrand?: T;
+    readonly __rtInjectTypeFnArgsFns?: [F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12];
+};
+export declare function getRunTypeId<T>(runType: RunType<T>, id?: InjectRunTypeId<T>): InjectRunTypeId<T>;
+export declare function getRunTypeId<T>(_value?: T, id?: InjectRunTypeId<T>): InjectRunTypeId<T>;
+export type CompTimeArgs<T> = T;
+export type CompTimeFnArgs<T> = T & {
+    readonly __rtCompTimeFnArgsBrand?: never;
+};
+export type CompTimeHints<T> = T;
+export type PureFunction<F> = F & {
+    readonly __rtPureFunctionBrand?: never;
+};
+export type PureFunctionFactory<F> = F & {
+    readonly __rtPureFunctionFactoryBrand?: never;
+};
+export type InjectPureFnId<F> = string & {
+    readonly __rtInjectPureFnIdBrand?: F;
+};
+export type InjectBatchId<Routes> = string & {
+    readonly __rtInjectBatchIdBrand?: Routes;
+};
+export type InjectApiMetadata<Api, Id extends string> = {
+    readonly __rtInjectApiMetadataBrand?: [Api, Id];
+};
+export type InjectBuildVersion<Api> = string & {
+    readonly __rtInjectBuildVersionBrand?: Api;
+};
+//# sourceMappingURL=markers.d.ts.map

package/dist/markers.js

@@ -0,0 +1,12 @@
+import { entryTupleKey, initFromTuple, isEntryTuple } from './runtypes/entryTuple.js';
+export function getRunTypeId(_valueOrSchema, id) {
+    if (isEntryTuple(id)) {
+        initFromTuple(id);
+        return entryTupleKey(id);
+    }
+    if (id === undefined) {
+        throw new Error('getRunTypeId(): no id injected. @mionjs/devtools must be active.');
+    }
+    return id;
+}
+//# sourceMappingURL=markers.js.map

package/dist/markers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markers.js","sourceRoot":"","sources":["../src/markers.ts"],"names":[],"mappings":"AAQA,OAAO,EAAC,aAAa,EAAE,aAAa,EAAE,YAAY,EAAC,MAAM,0BAA0B,CAAC;AA+GpF,MAAM,UAAU,YAAY,CAAI,cAA+B,EAAE,EAAuB;IACtF,IAAI,YAAY,CAAC,EAAE,CAAC,EAAE,CAAC;QACrB,aAAa,CAAC,EAAE,CAAC,CAAC;QAClB,OAAO,aAAa,CAAC,EAAE,CAAuB,CAAC;IACjD,CAAC;IACD,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CAAC,kEAAkE,CAAC,CAAC;IACtF,CAAC;IACD,OAAO,EAAwB,CAAC;AAClC,CAAC"}

package/dist/mion-pure-fns/@mionjs/run-types/-y__pOnrgnvRMz.js

@@ -0,0 +1,2 @@
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FMnJ72PqkyXHiSP} from './MnJ72PqkyXHiSP.js';
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2F$2Dy__pOnrgnvRMz=[2,()=>[__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FMnJ72PqkyXHiSP],,'@mionjs/run-types#pf_-y__pOnrgnvRMz',['utl'],'const isDate = utl.getPureFn(\'@mionjs/run-types#pf_MnJ72PqkyXHiSP\');\n  return function _is_mdy(value) {\n    const parts = value.split(\'-\');\n    return parts.length === 3 && isDate(parts[2], parts[0], parts[1]);\n  };',['@mionjs/run-types#pf_MnJ72PqkyXHiSP']];

package/dist/mion-pure-fns/@mionjs/run-types/0ofEnb55W0BDIY.js

@@ -0,0 +1,2 @@
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2F8Mj42N3ytEEn67} from './8Mj42N3ytEEn67.js';
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2F0ofEnb55W0BDIY=[2,()=>[__rt_pf$2F$40mionjs$2Frun$2Dtypes$2F8Mj42N3ytEEn67],,'@mionjs/run-types#pf_0ofEnb55W0BDIY',['utl'],'const canonicalJsonFn = utl.getPureFn(\'@mionjs/run-types#pf_8Mj42N3ytEEn67\');\n  // An array compares its ITEMS, and nothing in it is unique by construction.\n  // Primitives key a Set directly, since SameValueZero is exactly the partition the canonical form produces, so they build no strings at all.\n  // The two sets stay SEPARATE so a raw string cannot collide with an object\'s canonical form.\n  return function _uniqueArrayItems(arr) {\n    const len = arr.length;\n    if (len < 2) return true;\n    const primitives = new Set();\n    let objects = null;\n    for (let i = 0; i < len; i++) {\n      const item = arr[i];\n      if (item === null || typeof item !== \'object\') {\n        if (primitives.has(item)) return false;\n        primitives.add(item);\n        continue;\n      }\n      if (objects === null) objects = new Set();\n      const key = canonicalJsonFn(item);\n      if (objects.has(key)) return false;\n      objects.add(key);\n    }\n    return true;\n  };',['@mionjs/run-types#pf_8Mj42N3ytEEn67']];

package/dist/mion-pure-fns/@mionjs/run-types/18wDCH5CXZoQKV.js

@@ -0,0 +1,2 @@
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FVJiknJ2exR2oMF} from './VJiknJ2exR2oMF.js';
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2F18wDCH5CXZoQKV=[2,()=>[__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FVJiknJ2exR2oMF],,'@mionjs/run-types#pf_18wDCH5CXZoQKV',['utl'],'const luhnSumFn = utl.getPureFn(\'@mionjs/run-types#pf_VJiknJ2exR2oMF\');\n  return function _is_credit_card(value, params) {\n    if (typeof value !== \'string\' || value === \'\') return \'format\';\n    const separators = params.separators;\n    let count = 0;\n    // A separator only ever sits BETWEEN digits, so the character to the right of the cursor must be a\n    // digit whenever a separator is consumed, which rejects a leading / trailing one and two in a row.\n    let expectDigit = true;\n    for (let i = value.length - 1; i >= 0; i--) {\n      const charCode = value.charCodeAt(i);\n      if (charCode >= 48 && charCode <= 57) {\n        count++;\n        expectDigit = false;\n        continue;\n      }\n      if (expectDigit) return \'format\';\n      if (separators === undefined || separators.indexOf(value[i]) === -1) return \'format\';\n      expectDigit = true;\n    }\n    if (expectDigit) return \'format\';\n    if (count < 12 || count > 19) return \'format\';\n    return luhnSumFn(value) % 10 === 0 ? \'\' : \'checksum\';\n  };',['@mionjs/run-types#pf_VJiknJ2exR2oMF']];

package/dist/mion-pure-fns/@mionjs/run-types/2xtQHAMu-yOBo6.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2F2xtQHAMu$2DyOBo6=[2,,,'@mionjs/run-types#pf_2xtQHAMu-yOBo6',[],'function twoDigitsLE(s, at, max) {\n    const tens = s.charCodeAt(at) - 48;\n    const ones = s.charCodeAt(at + 1) - 48;\n    return tens >= 0 && tens <= 9 && ones >= 0 && ones <= 9 && tens * 10 + ones <= max;\n  }\n  return function _is_mmss(value) {\n    return value.length === 5 && value.charCodeAt(2) === 58 && twoDigitsLE(value, 0, 59) && twoDigitsLE(value, 3, 59);\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/5oCqd7YyfA9rEw.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2F5oCqd7YyfA9rEw=[2,,,'@mionjs/run-types#pf_5oCqd7YyfA9rEw',[],'const BASE = 36;\n  const TMIN = 1;\n  const TMAX = 26;\n  const SKEW = 38;\n  const DAMP = 700;\n  const INITIAL_BIAS = 72;\n  const INITIAL_N = 128;\n  const MAX_INT = 0x7fffffff;\n  function adapt(delta, numPoints, firstTime) {\n    let scaled = firstTime ? Math.floor(delta / DAMP) : delta >> 1;\n    scaled += Math.floor(scaled / numPoints);\n    let k = 0;\n    while (scaled > ((BASE - TMIN) * TMAX) >> 1) {\n      scaled = Math.floor(scaled / (BASE - TMIN));\n      k += BASE;\n    }\n    return k + Math.floor(((BASE - TMIN + 1) * scaled) / (scaled + SKEW));\n  }\n  function digitChar(digit) {\n    return String.fromCharCode(digit < 26 ? digit + 0x61 : digit - 26 + 0x30);\n  }\n  return function _punycode_encode(input) {\n    const points = [...input].map((char) => char.codePointAt(0));\n    const basic = points.filter((code) => code < 0x80);\n    let handled = basic.length;\n    let out = basic.map((code) => String.fromCharCode(code)).join(\'\');\n    if (handled) out += \'-\';\n    let n = INITIAL_N;\n    let delta = 0;\n    let bias = INITIAL_BIAS;\n    while (handled < points.length) {\n      let next = MAX_INT;\n      for (const code of points) if (code >= n && code < next) next = code;\n      if (next - n > Math.floor((MAX_INT - delta) / (handled + 1))) return false;\n      delta += (next - n) * (handled + 1);\n      n = next;\n      for (const code of points) {\n        if (code < n && ++delta > MAX_INT) return false;\n        if (code !== n) continue;\n        let remaining = delta;\n        for (let k = BASE; ; k += BASE) {\n          const threshold = k <= bias ? TMIN : k >= bias + TMAX ? TMAX : k - bias;\n          if (remaining < threshold) break;\n          out += digitChar(threshold + ((remaining - threshold) % (BASE - threshold)));\n          remaining = Math.floor((remaining - threshold) / (BASE - threshold));\n        }\n        out += digitChar(remaining);\n        bias = adapt(delta, handled + 1, handled === basic.length);\n        delta = 0;\n        handled++;\n      }\n      delta++;\n      n++;\n    }\n    return out;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/6E7qWsIwaFRGn6.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2F6E7qWsIwaFRGn6=[2,,,'@mionjs/run-types#pf_6E7qWsIwaFRGn6',[],'function digitsRun(s, start, end) {\n    for (let i = start; i < end; i++) {\n      const code = s.charCodeAt(i);\n      if (code < 48 || code > 57) return false;\n    }\n    return true;\n  }\n  return function _is_s_ms(secsAndMs) {\n    const len = secsAndMs.length;\n    if (len !== 2 && !(len === 6 && secsAndMs.charCodeAt(2) === 46)) return false;\n    const tens = secsAndMs.charCodeAt(0) - 48;\n    const ones = secsAndMs.charCodeAt(1) - 48;\n    if (tens < 0 || tens > 9 || ones < 0 || ones > 9 || tens * 10 + ones > 59) return false;\n    return len === 2 || digitsRun(secsAndMs, 3, 6);\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/6xkN1Qfs9nqO79.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2F6xkN1Qfs9nqO79=[2,,,'@mionjs/run-types#pf_6xkN1Qfs9nqO79',[],'// Backs the `checkUnknowns` key-count fast path: after validation an all-required object is clean iff its\n  // key count equals the declared prop count.\n  // Which counter is fastest inverts by engine: for-in on V8 (~19 vs ~25 ns/op), `Object.keys` on JavaScriptCore (~16 vs ~25).\n  // The factory runs ONCE at materialisation inside the target runtime, so the engine test is paid once and the counter stays branch-free.\n  // The two are NOT interchangeable: for-in also counts INHERITED enumerable properties, so the JSC arm tests the prototype per call.\n  // The "is Object.prototype itself clean" half cannot vary per input, so it is hoisted up here.\n  // The `!= null` half is for the same equivalence reason, not safety: for-in over null counts 0 where `Object.getPrototypeOf` throws.\n  // Together both branches answer identically for EVERY input, and the per-call guard measured free on JSC.\n  if (typeof Bun !== \'undefined\' && Object.keys(Object.prototype).length === 0) {\n    const objectProto = Object.prototype;\n    return function _countEnumKeys(obj) {\n      const proto = obj != null ? Object.getPrototypeOf(obj) : undefined;\n      if (proto === objectProto || proto === null) return Object.keys(obj).length;\n      let count = 0;\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      for (const _key in obj) count++;\n      return count;\n    };\n  }\n  return function _countEnumKeys(obj) {\n    let count = 0;\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    for (const _key in obj) count++;\n    return count;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/8Mj42N3ytEEn67.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2F8Mj42N3ytEEn67=[2,,,'@mionjs/run-types#pf_8Mj42N3ytEEn67',[],'// JSON equality as a string key: numbers by mathematical value (0 and -0 collide), objects by unordered key set, arrays by order.\n  // The runtime twin the mock walker uses is `canonicalJson` in mocking/structuralFormat.ts; the two MUST agree or mocks drift from validators.\n  // A primitive\'s key carries its `typeof` prefix, so the string \'{}\' and the value {} are different entries.\n  // Recursion rides a factory-LOCAL const: a factory body is inlined without its lexical environment, so self-naming reads as an outer capture (purefn-reads-outer-variable).\n  const canonical = (value) => {\n    if (value === null || typeof value !== \'object\') {\n      return typeof value === \'string\' ? JSON.stringify(value) : typeof value + \':\' + String(value);\n    }\n    if (Array.isArray(value)) return \'[\' + value.map(canonical).join(\',\') + \']\';\n    return (\n      \'{\' +\n      Object.keys(value)\n        .sort()\n        .map((key) => JSON.stringify(key) + \':\' + canonical(value[key]))\n        .join(\',\') +\n      \'}\'\n    );\n  };\n  return function _canonicalJson(value) {\n    return canonical(value);\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/A3KjzpjelkcBST.js

@@ -0,0 +1,2 @@
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FnsU8QeJCuCF8Kr} from './nsU8QeJCuCF8Kr.js';
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FA3KjzpjelkcBST=[2,()=>[__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FnsU8QeJCuCF8Kr],,'@mionjs/run-types#pf_A3KjzpjelkcBST',['utl'],'const NETWORK_RULES = (utl.getPureFn(\'@mionjs/run-types#pf_nsU8QeJCuCF8Kr\'))();\n  return function _matches_card_network(value, params) {\n    const networks = params.networks;\n    if (networks === undefined || networks.length === 0) return false;\n    const separators = params.separators;\n    let digits = value;\n    if (separators !== undefined) {\n      digits = \'\';\n      for (let i = 0; i < value.length; i++) {\n        if (separators.indexOf(value[i]) === -1) digits += value[i];\n      }\n    }\n    for (const network of networks) {\n      const rule = NETWORK_RULES[network];\n      if (rule === undefined) continue;\n      if (rule.lengths.indexOf(digits.length) === -1) continue;\n      for (const [low, high] of rule.prefixes) {\n        const head = digits.slice(0, low.length);\n        if (head >= low && head <= high) return true;\n      }\n    }\n    return false;\n  };',['@mionjs/run-types#pf_nsU8QeJCuCF8Kr']];

package/dist/mion-pure-fns/@mionjs/run-types/AgOXcprpjsrTKk.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FAgOXcprpjsrTKk=[2,,,'@mionjs/run-types#pf_AgOXcprpjsrTKk',[],'return function _isUUID(value, params) {\n    if (typeof value !== \'string\' || value.length !== 36) return false;\n    for (let i = 0; i < 36; i++) {\n      if (i === 8 || i === 13 || i === 18 || i === 23) {\n        if (value[i] !== \'-\') return false;\n      } else if (i === 14 && params.version !== \'any\') {\n        // The version-agnostic UUID (\'any\', JSON Schema `format: uuid`) treats slot 14 as ordinary hex.\n        if (value[i] !== params.version) return false;\n      } else {\n        const charCode = value.charCodeAt(i);\n        const is09 = charCode >= 48 && charCode <= 57;\n        const isaf = charCode >= 97 && charCode <= 102;\n        const isAF = charCode >= 65 && charCode <= 70;\n        if (!(is09 || isaf || isAF)) return false;\n      }\n    }\n    return true;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/E29ul2pUOyD_Ay.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FE29ul2pUOyD_Ay=[2,,,'@mionjs/run-types#pf_E29ul2pUOyD_Ay',[],'// RFC 5892 section 2.6 exception tables: derivable from no Unicode property, so spelled out.\n  const PVALID_EXCEPTIONS = [0x00df, 0x03c2, 0x06fd, 0x06fe, 0x0f0b, 0x3007];\n  const DISALLOWED_EXCEPTIONS = [0x0640, 0x07fa, 0x302e, 0x302f, 0x3031, 0x3032, 0x3033, 0x3034, 0x3035, 0x303b];\n  // Canonical_Combining_Class=Virama. JS regex has no escape for it.\n  const VIRAMA = [\n    0x094d, 0x09cd, 0x0a4d, 0x0acd, 0x0b4d, 0x0bcd, 0x0c4d, 0x0ccd, 0x0d3b, 0x0d3c, 0x0d4d, 0x0dca, 0x0e3a, 0x0eba, 0x0f84,\n    0x1039, 0x103a, 0x1714, 0x1734, 0x17d2, 0x1a60, 0x1b44, 0x1baa, 0x1bab, 0x1bf2, 0x1bf3, 0x2d7f, 0xa806, 0xa8c4, 0xa953,\n    0xa9c0, 0xaaf6, 0xabed, 0x10a3f, 0x11046, 0x1107f, 0x110b9, 0x11133, 0x11134, 0x111c0, 0x11235, 0x112ea, 0x1134d, 0x11442,\n    0x114c2, 0x115bf, 0x1163f, 0x116b6, 0x1172b, 0x11839, 0x119e0, 0x11a34, 0x11a99, 0x11c3f, 0x11d44, 0x11d45, 0x11d97,\n  ];\n  const greekRegexp = /\\p{Script=Greek}/u;\n  const hebrewRegexp = /\\p{Script=Hebrew}/u;\n  const katakanaContextRegexp = /[\\p{Script=Hiragana}\\p{Script=Katakana}\\p{Script=Han}]/u;\n  const allowedRegexp = /[\\p{L}\\p{M}\\p{N}]/u;\n  const markRegexp = /\\p{M}/u;\n  const arabicIndicRegexp = /[٠-٩]/u;\n  const extendedArabicIndicRegexp = /[۰-۹]/u;\n  // Joining_Type is not a JS regex property either, so the joining SCRIPTS stand in for it: enough to\n  // tell an Arabic neighbour from a Latin one.\n  const joiningRegexp = /[\\p{Script=Arabic}\\p{Script=Syriac}\\p{Script=Nko}\\p{Script=Mandaic}\\p{Script=Adlam}]\\p{M}*$/u;\n  return function _is_idna_label(label) {\n    if (label === \'\') return false;\n    if (label.startsWith(\'-\') || label.endsWith(\'-\')) return false;\n    // `--` in the 3rd and 4th position is reserved for the A-label prefix.\n    if (label.length > 3 && label[2] === \'-\' && label[3] === \'-\') return false;\n    const chars = [...label];\n    if (markRegexp.test(chars[0])) return false;\n    for (let i = 0; i < chars.length; i++) {\n      const char = chars[i];\n      const code = char.codePointAt(0);\n      if (DISALLOWED_EXCEPTIONS.indexOf(code) !== -1) return false;\n      if (PVALID_EXCEPTIONS.indexOf(code) !== -1) continue;\n      if (char === \'-\') continue;\n      if (code === 0x200c || code === 0x200d) {\n        // CONTEXTJ: a joiner is allowed directly after a Virama, and ZWNJ also\n        // between joining letters (RFC 5892 A.1 rule 2).\n        if (i === 0) return false;\n        if (VIRAMA.indexOf(chars[i - 1].codePointAt(0)) !== -1) continue;\n        if (code !== 0x200c) return false;\n        if (!joiningRegexp.test(chars.slice(0, i).join(\'\'))) return false;\n        continue;\n      }\n      // CONTEXTO, one rule per character, each decided by its neighbours.\n      if (code === 0x00b7) {\n        if (chars[i - 1] !== \'l\' || chars[i + 1] !== \'l\') return false;\n        continue;\n      }\n      if (code === 0x0375) {\n        if (!chars[i + 1] || !greekRegexp.test(chars[i + 1])) return false;\n        continue;\n      }\n      if (code === 0x05f3 || code === 0x05f4) {\n        if (!chars[i - 1] || !hebrewRegexp.test(chars[i - 1])) return false;\n        continue;\n      }\n      if (code === 0x30fb) {\n        if (!katakanaContextRegexp.test(label)) return false;\n        continue;\n      }\n      if (arabicIndicRegexp.test(char)) {\n        if (extendedArabicIndicRegexp.test(label)) return false;\n        continue;\n      }\n      if (extendedArabicIndicRegexp.test(char)) {\n        if (arabicIndicRegexp.test(label)) return false;\n        continue;\n      }\n      if (!allowedRegexp.test(char)) return false;\n    }\n    return true;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/EG8OkOOSnT9bZn.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FEG8OkOOSnT9bZn=[2,,,'@mionjs/run-types#pf_EG8OkOOSnT9bZn',[],'// Length gate first: this runs on EVERY ip validation, and a case-blind regex call costs more than\n  // the answer is worth when the length already says no.\n  return function _is_local_host(ip) {\n    return ip.length === 9 && ip.toLowerCase() === \'localhost\';\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/EYsxRHRDgAykA_.js

@@ -0,0 +1,3 @@
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2Fcgwpjq6rGsI8jb} from './cgwpjq6rGsI8jb.js';
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2Fd8U9HjmMsNFd6Z} from './d8U9HjmMsNFd6Z.js';
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FEYsxRHRDgAykA_=[2,()=>[__rt_pf$2F$40mionjs$2Frun$2Dtypes$2Fcgwpjq6rGsI8jb,__rt_pf$2F$40mionjs$2Frun$2Dtypes$2Fd8U9HjmMsNFd6Z],,'@mionjs/run-types#pf_EYsxRHRDgAykA_',['utl'],'const isH = utl.getPureFn(\'@mionjs/run-types#pf_d8U9HjmMsNFd6Z\');\n  const isM = utl.getPureFn(\'@mionjs/run-types#pf_cgwpjq6rGsI8jb\');\n  return function _is_tz(timeZone) {\n    if (timeZone === \'Z\' || timeZone === \'z\') return true;\n    const parts = timeZone.split(\':\');\n    return parts.length === 2 && isH(parts[0]) && isM(parts[1]);\n  };',['@mionjs/run-types#pf_cgwpjq6rGsI8jb','@mionjs/run-types#pf_d8U9HjmMsNFd6Z']];

package/dist/mion-pure-fns/@mionjs/run-types/Eube1z0GFHuqlM.js

@@ -0,0 +1,2 @@
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FMnJ72PqkyXHiSP} from './MnJ72PqkyXHiSP.js';
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FEube1z0GFHuqlM=[2,()=>[__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FMnJ72PqkyXHiSP],,'@mionjs/run-types#pf_Eube1z0GFHuqlM',['utl'],'const isDate = utl.getPureFn(\'@mionjs/run-types#pf_MnJ72PqkyXHiSP\');\n  return function _is_dm(value) {\n    const parts = value.split(\'-\');\n    return parts.length === 2 && isDate(undefined, parts[1], parts[0]);\n  };',['@mionjs/run-types#pf_MnJ72PqkyXHiSP']];

package/dist/mion-pure-fns/@mionjs/run-types/GA20s6bj41GC1A.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FGA20s6bj41GC1A=[2,,,'@mionjs/run-types#pf_GA20s6bj41GC1A',[],'const BASE = 36;\n  const TMIN = 1;\n  const TMAX = 26;\n  const SKEW = 38;\n  const DAMP = 700;\n  const INITIAL_BIAS = 72;\n  const INITIAL_N = 128;\n  const MAX_INT = 0x7fffffff;\n  function adapt(delta, numPoints, firstTime) {\n    let scaled = firstTime ? Math.floor(delta / DAMP) : delta >> 1;\n    scaled += Math.floor(scaled / numPoints);\n    let k = 0;\n    while (scaled > ((BASE - TMIN) * TMAX) >> 1) {\n      scaled = Math.floor(scaled / (BASE - TMIN));\n      k += BASE;\n    }\n    return k + Math.floor(((BASE - TMIN + 1) * scaled) / (scaled + SKEW));\n  }\n  return function _punycode_decode(input) {\n    const out = [];\n    let index = input.lastIndexOf(\'-\');\n    if (index > 0) {\n      for (let i = 0; i < index; i++) {\n        const code = input.charCodeAt(i);\n        if (code >= 0x80) return false;\n        out.push(code);\n      }\n      index++;\n    } else index = 0;\n    let n = INITIAL_N;\n    let bias = INITIAL_BIAS;\n    let i = 0;\n    while (index < input.length) {\n      const previousI = i;\n      for (let weight = 1, k = BASE; ; k += BASE) {\n        if (index >= input.length) return false;\n        const code = input.charCodeAt(index++);\n        const digit =\n          code >= 0x30 && code <= 0x39\n            ? code - 0x30 + 26\n            : code >= 0x61 && code <= 0x7a\n              ? code - 0x61\n              : code >= 0x41 && code <= 0x5a\n                ? code - 0x41\n                : -1;\n        if (digit < 0 || digit > (MAX_INT - i) / weight) return false;\n        i += digit * weight;\n        const threshold = k <= bias ? TMIN : k >= bias + TMAX ? TMAX : k - bias;\n        if (digit < threshold) break;\n        if (weight > Math.floor(MAX_INT / (BASE - threshold))) return false;\n        weight *= BASE - threshold;\n      }\n      bias = adapt(i - previousI, out.length + 1, previousI === 0);\n      if (Math.floor(i / (out.length + 1)) > MAX_INT - n) return false;\n      n += Math.floor(i / (out.length + 1));\n      i %= out.length + 1;\n      if (n > 0x10ffff || (n >= 0xd800 && n <= 0xdfff)) return false;\n      out.splice(i++, 0, n);\n    }\n    return String.fromCodePoint(...out);\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/GfQK19ktpvibuZ.js

@@ -0,0 +1,2 @@
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FMnJ72PqkyXHiSP} from './MnJ72PqkyXHiSP.js';
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FGfQK19ktpvibuZ=[2,()=>[__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FMnJ72PqkyXHiSP],,'@mionjs/run-types#pf_GfQK19ktpvibuZ',['utl'],'const isDate = utl.getPureFn(\'@mionjs/run-types#pf_MnJ72PqkyXHiSP\');\n  return function _is_ym(value) {\n    const parts = value.split(\'-\');\n    return parts.length === 2 && isDate(parts[0], parts[1]);\n  };',['@mionjs/run-types#pf_MnJ72PqkyXHiSP']];

package/dist/mion-pure-fns/@mionjs/run-types/IyjvBbz0zSlgCJ.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FIyjvBbz0zSlgCJ=[2,,,'@mionjs/run-types#pf_IyjvBbz0zSlgCJ',[],'function twoDigitsLE(s, at, max) {\n    const tens = s.charCodeAt(at) - 48;\n    const ones = s.charCodeAt(at + 1) - 48;\n    return tens >= 0 && tens <= 9 && ones >= 0 && ones <= 9 && tens * 10 + ones <= max;\n  }\n  return function _is_hhmmss(value) {\n    return (\n      value.length === 8 &&\n      value.charCodeAt(2) === 58 &&\n      value.charCodeAt(5) === 58 &&\n      twoDigitsLE(value, 0, 23) &&\n      twoDigitsLE(value, 3, 59) &&\n      twoDigitsLE(value, 6, 59)\n    );\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/LqTR2O-h6MYq9J.js

@@ -0,0 +1,4 @@
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2F_3Pmrr5aNmyNi4} from './_3Pmrr5aNmyNi4.js';
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FndkQPoji6DFHx2} from './ndkQPoji6DFHx2.js';
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FrgWveqNi_HeFF8} from './rgWveqNi_HeFF8.js';
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FLqTR2O$2Dh6MYq9J=[2,()=>[__rt_pf$2F$40mionjs$2Frun$2Dtypes$2F_3Pmrr5aNmyNi4,__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FndkQPoji6DFHx2,__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FrgWveqNi_HeFF8],,'@mionjs/run-types#pf_LqTR2O-h6MYq9J',['utl'],'// The three engines return a failure MODE (\'\' when good), not a boolean.\n  const isIPV4Fn = utl.getPureFn(\'@mionjs/run-types#pf__3Pmrr5aNmyNi4\');\n  const isIPV6Fn = utl.getPureFn(\'@mionjs/run-types#pf_ndkQPoji6DFHx2\');\n  const isIdnHostnameFn = utl.getPureFn(\'@mionjs/run-types#pf_rgWveqNi_HeFF8\');\n  // Same label separators the host-name engine splits on, redeclared here because each factory keeps\n  // its own tables: the extractor lifts the body alone.\n  const idnDotRegexp = /[.。．｡]/;\n  const asciiAtextRegexp = /^[A-Za-z0-9!#$%&\'*+/=?^_`{|}~-]+$/;\n  // The internationalized local part widens the repertoire rather than listing it: anything that is\n  // not a separator, a space, or a bracket.\n  const idnAtextRegexp = /^[^ \\t\\r\\n@.[\\]]+$/u;\n  const bareQuoteRegexp = /(^|[^\\\\])"/;\n  function isQuoted(local) {\n    if (local.length < 2 || local[0] !== \'"\' || local[local.length - 1] !== \'"\') return false;\n    // A bare quote inside would have ended the string early.\n    return !bareQuoteRegexp.test(local.substring(1, local.length - 1));\n  }\n  function isLocalPart(local, idn) {\n    if (local === \'\') return false;\n    if (isQuoted(local)) return true;\n    const atextRegexp = idn ? idnAtextRegexp : asciiAtextRegexp;\n    const parts = local.split(\'.\');\n    // A dot separates atoms, so it may not lead, trail, or repeat.\n    for (const part of parts) if (part === \'\' || !atextRegexp.test(part)) return false;\n    return true;\n  }\n  // Returns the FAILURE MODE rather than a boolean, naming WHICH PART is wrong: \'\' good, \'format\' (no\n  // \'@\' at all), \'localPart\' (before the last \'@\'), \'domain\' (a named domain after it) or\n  // \'addressLiteral\' (a bracketed IP literal after it). That feeds the `errorType` of the emitted\n  // format error; validate compares against \'\' and pays nothing for it.\n  return function _is_email_address(value, params) {\n    // The LAST \'@\' separates: a quoted local part may contain one of its own.\n    const at = value.lastIndexOf(\'@\');\n    if (at === -1) return \'format\';\n    if (at === 0 || !isLocalPart(value.substring(0, at), params.idn === true)) return \'localPart\';\n    if (at === value.length - 1) return \'domain\';\n    const domain = value.substring(at + 1);\n    if (domain[0] === \'[\' && domain[domain.length - 1] === \']\') {\n      const literal = domain.substring(1, domain.length - 1);\n      const literalMode =\n        literal.substring(0, 5) === \'IPv6:\'\n          ? isIPV6Fn(literal.substring(5), {version: 6, allowLocalHost: true})\n          : isIPV4Fn(literal, {version: 4, allowLocalHost: false});\n      return literalMode === \'\' ? \'\' : \'addressLiteral\';\n    }\n    // The dotted-TLD rule (see the factory comment): a bare one-label domain\n    // is a valid HOST NAME but not an address\'s domain.\n    if (params.idn === true ? !idnDotRegexp.test(domain) : domain.indexOf(\'.\') === -1) return \'domain\';\n    return isIdnHostnameFn(domain, {idn: params.idn === true}) === \'\' ? \'\' : \'domain\';\n  };',['@mionjs/run-types#pf__3Pmrr5aNmyNi4','@mionjs/run-types#pf_ndkQPoji6DFHx2','@mionjs/run-types#pf_rgWveqNi_HeFF8']];

package/dist/mion-pure-fns/@mionjs/run-types/MnJ72PqkyXHiSP.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FMnJ72PqkyXHiSP=[2,,,'@mionjs/run-types#pf_MnJ72PqkyXHiSP',[],'return function _isDateString(year, month, day) {\n    let y;\n    if (year) {\n      if (year.length !== 4) return false;\n      y = Number(year);\n      if (isNaN(y) || y < 0 || y > 9999) return false;\n    }\n    if (month.length !== 2) return false;\n    const m = Number(month);\n    if (isNaN(m) || m < 1 || m > 12) return false;\n    if (day) {\n      if (day.length !== 2) return false;\n      const d = Number(day);\n      if (isNaN(d) || d < 1 || d > 31) return false;\n      if (m === 2) {\n        if (d > 29) return false;\n        if (y && d === 29 && !(y % 4 === 0 && (y % 100 !== 0 || y % 400 === 0))) return false;\n      } else if ((m === 4 || m === 6 || m === 9 || m === 11) && d > 30) {\n        return false;\n      }\n    }\n    return true;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/NJ9TCGDnkv_9Mn.js

@@ -0,0 +1,2 @@
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FMnJ72PqkyXHiSP} from './MnJ72PqkyXHiSP.js';
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FNJ9TCGDnkv_9Mn=[2,()=>[__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FMnJ72PqkyXHiSP],,'@mionjs/run-types#pf_NJ9TCGDnkv_9Mn',['utl'],'const isDate = utl.getPureFn(\'@mionjs/run-types#pf_MnJ72PqkyXHiSP\');\n  return function _is_md(value) {\n    const parts = value.split(\'-\');\n    return parts.length === 2 && isDate(undefined, parts[0], parts[1]);\n  };',['@mionjs/run-types#pf_MnJ72PqkyXHiSP']];

package/dist/mion-pure-fns/@mionjs/run-types/OCJ1B0-ZCAwagS.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FOCJ1B0$2DZCAwagS=[2,,,'@mionjs/run-types#pf_OCJ1B0-ZCAwagS',[],'function twoDigitsLE(s, at, max) {\n    const tens = s.charCodeAt(at) - 48;\n    const ones = s.charCodeAt(at + 1) - 48;\n    return tens >= 0 && tens <= 9 && ones >= 0 && ones <= 9 && tens * 10 + ones <= max;\n  }\n  return function _is_iso(value) {\n    const len = value.length;\n    if (len !== 8 && !(len === 12 && value.charCodeAt(8) === 46)) return false;\n    if (value.charCodeAt(2) !== 58 || value.charCodeAt(5) !== 58) return false;\n    if (!twoDigitsLE(value, 0, 23) || !twoDigitsLE(value, 3, 59) || !twoDigitsLE(value, 6, 59)) return false;\n    for (let i = 9; i < len; i++) {\n      const code = value.charCodeAt(i);\n      if (code < 48 || code > 57) return false;\n    }\n    return true;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/PQVLEBllZckw8I.js

@@ -0,0 +1,2 @@
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FMnJ72PqkyXHiSP} from './MnJ72PqkyXHiSP.js';
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FPQVLEBllZckw8I=[2,()=>[__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FMnJ72PqkyXHiSP],,'@mionjs/run-types#pf_PQVLEBllZckw8I',['utl'],'const isDate = utl.getPureFn(\'@mionjs/run-types#pf_MnJ72PqkyXHiSP\');\n  return function _is_dmy(value) {\n    const parts = value.split(\'-\');\n    return parts.length === 3 && isDate(parts[2], parts[1], parts[0]);\n  };',['@mionjs/run-types#pf_MnJ72PqkyXHiSP']];

package/dist/mion-pure-fns/@mionjs/run-types/Qd_9GJQlOCVqDe.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FQd_9GJQlOCVqDe=[2,,,'@mionjs/run-types#pf_Qd_9GJQlOCVqDe',[],'return function _is_ecma_regex(value) {\n    try {\n      new RegExp(value, \'u\');\n      return true;\n    } catch {\n      return false;\n    }\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/R0IFkkw4SM2gvv.js

@@ -0,0 +1,2 @@
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2F8Mj42N3ytEEn67} from './8Mj42N3ytEEn67.js';
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FR0IFkkw4SM2gvv=[2,()=>[__rt_pf$2F$40mionjs$2Frun$2Dtypes$2F8Mj42N3ytEEn67],,'@mionjs/run-types#pf_R0IFkkw4SM2gvv',['utl'],'const canonicalJsonFn = utl.getPureFn(\'@mionjs/run-types#pf_8Mj42N3ytEEn67\');\n  // A Map compares its ENTRIES, the `[key, value]` PAIRS that are its wire form.\n  // A primitive key is unique by construction, so its whole pair is too and is skipped: `Map<string, BigObject>` canonicalises nothing.\n  // An object key may repeat by content, so its pair is canonicalised whole: two content-equal keys with DIFFERENT values pass.\n  return function _uniqueMapEntries(map) {\n    let objects = null;\n    for (const [key, value] of map) {\n      if (key === null || typeof key !== \'object\') continue;\n      if (objects === null) objects = new Set();\n      const pairKey = canonicalJsonFn([key, value]);\n      if (objects.has(pairKey)) return false;\n      objects.add(pairKey);\n    }\n    return true;\n  };',['@mionjs/run-types#pf_8Mj42N3ytEEn67']];

package/dist/mion-pure-fns/@mionjs/run-types/THkAA-KNR1HeAe.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FTHkAA$2DKNR1HeAe=[2,,,'@mionjs/run-types#pf_THkAA-KNR1HeAe',[],'return function _date_to_ms(value, layout) {\n    const parts = value.split(\'-\');\n    // Canonical fill for yearless layouts (MM-DD / DD-MM), which MUST match Go\'s defaultFillYear in\n    // literals.go; 2000 is a leap year so \'02-29\' is representable. A literal, not an outer const:\n    // pure-fn factories can\'t capture outer-scope bindings.\n    let year = 2000;\n    let month = 1;\n    let day = 1;\n    switch (layout) {\n      case \'ISO\':\n      case \'YYYY-MM-DD\':\n        year = Number(parts[0]);\n        month = Number(parts[1]);\n        day = Number(parts[2]);\n        break;\n      case \'DD-MM-YYYY\':\n        day = Number(parts[0]);\n        month = Number(parts[1]);\n        year = Number(parts[2]);\n        break;\n      case \'MM-DD-YYYY\':\n        month = Number(parts[0]);\n        day = Number(parts[1]);\n        year = Number(parts[2]);\n        break;\n      case \'YYYY-MM\':\n        year = Number(parts[0]);\n        month = Number(parts[1]);\n        break;\n      case \'MM-DD\':\n        month = Number(parts[0]);\n        day = Number(parts[1]);\n        break;\n      case \'DD-MM\':\n        day = Number(parts[0]);\n        month = Number(parts[1]);\n        break;\n    }\n    return Date.UTC(year, month - 1, day, 0, 0, 0, 0);\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/VJiknJ2exR2oMF.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FVJiknJ2exR2oMF=[2,,,'@mionjs/run-types#pf_VJiknJ2exR2oMF',[],'return function _luhn_sum(value) {\n    let sum = 0;\n    let double = false;\n    for (let i = value.length - 1; i >= 0; i--) {\n      const charCode = value.charCodeAt(i);\n      if (charCode < 48 || charCode > 57) continue;\n      let digit = charCode - 48;\n      if (double) {\n        digit *= 2;\n        if (digit > 9) digit -= 9;\n      }\n      sum += digit;\n      double = !double;\n    }\n    return sum;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/XYGjy-tcgDROBw.js

@@ -0,0 +1,2 @@
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2F8Mj42N3ytEEn67} from './8Mj42N3ytEEn67.js';
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FXYGjy$2DtcgDROBw=[2,()=>[__rt_pf$2F$40mionjs$2Frun$2Dtypes$2F8Mj42N3ytEEn67],,'@mionjs/run-types#pf_XYGjy-tcgDROBw',['utl'],'const canonicalJsonFn = utl.getPureFn(\'@mionjs/run-types#pf_8Mj42N3ytEEn67\');\n  // A Set\'s primitive members are already unique by construction (SameValueZero), so only object members are canonicalised.\n  // That is why `Set<{id: number}>` needs the keyword at all: it may hold two structurally equal objects.\n  return function _uniqueSetMembers(set) {\n    let objects = null;\n    for (const member of set) {\n      if (member === null || typeof member !== \'object\') continue;\n      if (objects === null) objects = new Set();\n      const key = canonicalJsonFn(member);\n      if (objects.has(key)) return false;\n      objects.add(key);\n    }\n    return true;\n  };',['@mionjs/run-types#pf_8Mj42N3ytEEn67']];

package/dist/mion-pure-fns/@mionjs/run-types/Z2sc5xQPKB0oav.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FZ2sc5xQPKB0oav=[2,,,'@mionjs/run-types#pf_Z2sc5xQPKB0oav',[],'const highSurrogateRegexp = /[\\uD800-\\uDBFF]/;\n  return function _code_point_length(value) {\n    const len = value.length;\n    if (len > 24 && !highSurrogateRegexp.test(value)) return len;\n    let count = len;\n    for (let i = 0; i < len; i++) {\n      const code = value.charCodeAt(i);\n      if (code >= 0xd800 && code <= 0xdbff && i + 1 < len) {\n        i++;\n        count--;\n      }\n    }\n    return count;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/_3Pmrr5aNmyNi4.js

@@ -0,0 +1,2 @@
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FEG8OkOOSnT9bZn} from './EG8OkOOSnT9bZn.js';
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2F_3Pmrr5aNmyNi4=[2,()=>[__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FEG8OkOOSnT9bZn],,'@mionjs/run-types#pf__3Pmrr5aNmyNi4',['utl'],'const isLocalHostFn = utl.getPureFn(\'@mionjs/run-types#pf_EG8OkOOSnT9bZn\');\n  // Dotted quad, ASCII digits only. Anchored and `Number`-free on purpose: `Number(\'\')` is 0,\n  // `Number(\'0x7f\')` is 127 and `Number(\' 1\\n\')` is 1, so a coercion-based octet check silently accepts\n  // `192.168..1`, `0x7f.0.0.1` and trailing whitespace. `\\d` stays ASCII under every flag, which keeps\n  // full-width and Bengali digits out.\n  const ipv4Regexp = /^(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)$/;\n  return function _is_ip_v4(ip, params) {\n    let address = ip;\n    let portS;\n    if (params.allowPort) {\n      const parts = ip.split(\':\');\n      if (parts.length > 2) return \'address\';\n      address = parts[0];\n      portS = parts[1];\n    }\n    // The address is judged BEFORE the port: "that is not an address" outranks\n    // "bad port" when both are wrong.\n    if (isLocalHostFn(address)) {\n      if (params.allowLocalHost !== true) return \'address\';\n    } else if (!ipv4Regexp.test(address)) return \'address\';\n    if (portS && (!/^\\d{1,5}$/.test(portS) || Number(portS) > 65535)) return \'port\';\n    return \'\';\n  };',['@mionjs/run-types#pf_EG8OkOOSnT9bZn']];

package/dist/mion-pure-fns/@mionjs/run-types/cgwpjq6rGsI8jb.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2Fcgwpjq6rGsI8jb=[2,,,'@mionjs/run-types#pf_cgwpjq6rGsI8jb',[],'return function _is_m(mins) {\n    if (mins.length !== 2) return false;\n    const tens = mins.charCodeAt(0) - 48;\n    const ones = mins.charCodeAt(1) - 48;\n    return tens >= 0 && tens <= 9 && ones >= 0 && ones <= 9 && tens * 10 + ones <= 59;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/d8U9HjmMsNFd6Z.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2Fd8U9HjmMsNFd6Z=[2,,,'@mionjs/run-types#pf_d8U9HjmMsNFd6Z',[],'return function _is_h(hours) {\n    if (hours.length !== 2) return false;\n    const tens = hours.charCodeAt(0) - 48;\n    const ones = hours.charCodeAt(1) - 48;\n    return tens >= 0 && tens <= 9 && ones >= 0 && ones <= 9 && tens * 10 + ones <= 23;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/fL3v1v6aVZwJ7-.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FfL3v1v6aVZwJ7$2D=[2,,,'@mionjs/run-types#pf_fL3v1v6aVZwJ7-',[],'const MAX_UNKNOWN_KEYS = 10;\n  return function _getUnknownKeysFromArray(obj, keys) {\n    const unknownKeys = [];\n    for (const prop in obj) {\n      let found = false;\n      for (let j = 0; j < keys.length; j++) {\n        if (keys[j] === prop) {\n          found = true;\n          break;\n        }\n      }\n      if (!found) {\n        unknownKeys.push(prop);\n        if (unknownKeys.length >= MAX_UNKNOWN_KEYS) throw new Error(\'Too many unknown keys\');\n      }\n    }\n    return unknownKeys;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/gFl-yXbCxJqWgQ.js

@@ -0,0 +1,2 @@
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FMnJ72PqkyXHiSP} from './MnJ72PqkyXHiSP.js';
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FgFl$2DyXbCxJqWgQ=[2,()=>[__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FMnJ72PqkyXHiSP],,'@mionjs/run-types#pf_gFl-yXbCxJqWgQ',['utl'],'const isDate = utl.getPureFn(\'@mionjs/run-types#pf_MnJ72PqkyXHiSP\');\n  return function _is_ymd(value) {\n    const parts = value.split(\'-\');\n    return parts.length === 3 && isDate(parts[0], parts[1], parts[2]);\n  };',['@mionjs/run-types#pf_MnJ72PqkyXHiSP']];

package/dist/mion-pure-fns/@mionjs/run-types/hiotRbfSKFAuK4.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FhiotRbfSKFAuK4=[2,,,'@mionjs/run-types#pf_hiotRbfSKFAuK4',[],'function twoDigitsLE(s, at, max) {\n    const tens = s.charCodeAt(at) - 48;\n    const ones = s.charCodeAt(at + 1) - 48;\n    return tens >= 0 && tens <= 9 && ones >= 0 && ones <= 9 && tens * 10 + ones <= max;\n  }\n  return function _is_hhmm(value) {\n    return value.length === 5 && value.charCodeAt(2) === 58 && twoDigitsLE(value, 0, 23) && twoDigitsLE(value, 3, 59);\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/lFYcgG5ZSI-8em.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FlFYcgG5ZSI$2D8em=[2,,,'@mionjs/run-types#pf_lFYcgG5ZSI-8em',[],'return function _is_s_leap(secsAndMs) {\n    const len = secsAndMs.length;\n    if (len < 2) return false;\n    const tens = secsAndMs.charCodeAt(0) - 48;\n    const ones = secsAndMs.charCodeAt(1) - 48;\n    if (tens < 0 || tens > 9 || ones < 0 || ones > 9 || tens * 10 + ones > 60) return false;\n    if (len === 2) return true;\n    if (secsAndMs.charCodeAt(2) !== 46 || len === 3) return false;\n    for (let i = 3; i < len; i++) {\n      const code = secsAndMs.charCodeAt(i);\n      if (code < 48 || code > 57) return false;\n    }\n    return true;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/n_ZOWff4X3qBMQ.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2Fn_ZOWff4X3qBMQ=[2,,,'@mionjs/run-types#pf_n_ZOWff4X3qBMQ',[],'return function _is_s(secs) {\n    if (secs.length !== 2) return false;\n    const tens = secs.charCodeAt(0) - 48;\n    const ones = secs.charCodeAt(1) - 48;\n    return tens >= 0 && tens <= 9 && ones >= 0 && ones <= 9 && tens * 10 + ones <= 59;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/ndkQPoji6DFHx2.js

@@ -0,0 +1,2 @@
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FEG8OkOOSnT9bZn} from './EG8OkOOSnT9bZn.js';
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FndkQPoji6DFHx2=[2,()=>[__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FEG8OkOOSnT9bZn],,'@mionjs/run-types#pf_ndkQPoji6DFHx2',['utl'],'const isLocalHostFn = utl.getPureFn(\'@mionjs/run-types#pf_EG8OkOOSnT9bZn\');\n  const ipv6PortRegexp = /^\\[([^\\]]+)\\](?::(\\d+))?$/;\n  // The group walkers work on index RANGES of the one address string: a split-and-regex version of the\n  // same rules measured ~2x slower, all of it allocation and per-group regex overhead.\n  // isIPv4Quad: dotted quad over [start, end) with the ipv4 octet rules, leading zeros tolerated.\n  function isIPv4Quad(s, start, end) {\n    let octets = 0;\n    let val = 0;\n    let digits = 0;\n    for (let i = start; i <= end; i++) {\n      if (i === end || s.charCodeAt(i) === 46) {\n        if (digits === 0) return false;\n        octets++;\n        if (octets > 4) return false;\n        if (i === end) return octets === 4;\n        val = 0;\n        digits = 0;\n        continue;\n      }\n      const code = s.charCodeAt(i);\n      if (code < 48 || code > 57) return false;\n      if (digits === 3 || (val = val * 10 + (code - 48)) > 255) return false;\n      digits++;\n    }\n    return false;\n  }\n  // isHexGroup: one 16-bit group over [start, end) — 1-4 hex digits.\n  function isHexGroup(s, start, end) {\n    const n = end - start;\n    if (n < 1 || n > 4) return false;\n    for (let i = start; i < end; i++) {\n      const code = s.charCodeAt(i);\n      if (!((code >= 48 && code <= 57) || (code >= 97 && code <= 102) || (code >= 65 && code <= 70))) return false;\n    }\n    return true;\n  }\n  // Counts the 16-bit groups in one `:`-separated run [start, end), or -1 when a group is malformed. A\n  // dotted quad is accepted in the LAST position only (ipv4-mapped) and counts as the two groups it encodes.\n  function countGroups(s, start, end, allowIPv4Tail) {\n    if (start >= end) return 0;\n    let count = 0;\n    let groupStart = start;\n    for (let i = start; i <= end; i++) {\n      if (i === end || s.charCodeAt(i) === 58) {\n        if (allowIPv4Tail && i === end && isIPv4Quad(s, groupStart, i)) count += 2;\n        else if (isHexGroup(s, groupStart, i)) count += 1;\n        else return -1;\n        groupStart = i + 1;\n      }\n    }\n    return count;\n  }\n  // isAddress: `::` elides one or more all-zero groups and may appear at most once; a lone leading /\n  // trailing `:` is not an elision, so those runs come back with an empty group and are rejected.\n  function isAddress(address) {\n    const elision = address.indexOf(\'::\');\n    if (elision === -1) return countGroups(address, 0, address.length, true) === 8;\n    if (address.indexOf(\'::\', elision + 1) !== -1) return false;\n    const head = countGroups(address, 0, elision, false);\n    const tail = countGroups(address, elision + 2, address.length, true);\n    if (head === -1 || tail === -1) return false;\n    // The elision stands for at least one group, so the written ones must leave\n    // room for it.\n    return head + tail <= 7;\n  }\n  return function _is_ip_v6(ip, params) {\n    let address = ip;\n    let port;\n    if (params.allowPort) {\n      // With a port the address MUST be bracketed, `[addr]:port`; a bare `::1` is then not in the\n      // accepted shape, which counts as an address problem.\n      const match = ip.match(ipv6PortRegexp);\n      if (!match) return \'address\';\n      address = match[1];\n      port = match[2];\n    }\n    // The address is judged BEFORE the port, same as isIPV4.\n    if (isLocalHostFn(address)) {\n      if (params.allowLocalHost !== true) return \'address\';\n    } else if (!isAddress(address)) return \'address\';\n    if (port && Number(port) > 65535) return \'port\';\n    return \'\';\n  };',['@mionjs/run-types#pf_EG8OkOOSnT9bZn']];

package/dist/mion-pure-fns/@mionjs/run-types/nsU8QeJCuCF8Kr.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FnsU8QeJCuCF8Kr=[2,,,'@mionjs/run-types#pf_nsU8QeJCuCF8Kr',[],'const RULES = {\n    visa: {prefixes: [[\'4\', \'4\']], lengths: [13, 16, 19]},\n    mastercard: {\n      prefixes: [\n        [\'51\', \'55\'],\n        [\'2221\', \'2720\'],\n      ],\n      lengths: [16],\n    },\n    amex: {\n      prefixes: [\n        [\'34\', \'34\'],\n        [\'37\', \'37\'],\n      ],\n      lengths: [15],\n    },\n    discover: {\n      prefixes: [\n        [\'6011\', \'6011\'],\n        [\'644\', \'649\'],\n        [\'65\', \'65\'],\n        [\'622126\', \'622925\'],\n      ],\n      lengths: [16, 19],\n    },\n    jcb: {prefixes: [[\'3528\', \'3589\']], lengths: [16, 17, 18, 19]},\n    diners: {\n      prefixes: [\n        [\'300\', \'305\'],\n        [\'3095\', \'3095\'],\n        [\'36\', \'36\'],\n        [\'38\', \'39\'],\n      ],\n      lengths: [14, 15, 16, 17, 18, 19],\n    },\n    unionpay: {prefixes: [[\'62\', \'62\']], lengths: [16, 17, 18, 19]},\n    maestro: {\n      prefixes: [\n        [\'5018\', \'5018\'],\n        [\'5020\', \'5020\'],\n        [\'5038\', \'5038\'],\n        [\'5893\', \'5893\'],\n        [\'6304\', \'6304\'],\n        [\'6759\', \'6759\'],\n        [\'6761\', \'6763\'],\n      ],\n      lengths: [12, 13, 14, 15, 16, 17, 18, 19],\n    },\n  };\n  Object.freeze(RULES);\n  return function _card_network_rules() {\n    return RULES;\n  };',[]];