@matatbread/typia/lib/index.mjs

Superfast runtime validators with only one line

/**
 * @internal
 */
function assertFunction() {
    halt$8("assertFunction");
}
/**
 * @internal
 */
function assertParameters() {
    halt$8("assertParameters");
}
/**
 * @internal
 */
function assertReturn() {
    halt$8("assertReturn");
}
/**
 * @internal
 */
function assertEqualsFunction() {
    halt$8("assertEqualsFunction");
}
/**
 * @internal
 */
function assertEqualsParameters() {
    halt$8("assertEqualsParameters");
}
/**
 * @internal
 */
function assertEqualsReturn() {
    halt$8("assertEqualsReturn");
}
/**
 * @internal
 */
function isFunction() {
    halt$8("isFunction");
}
/**
 * @internal
 */
function isParameters() {
    halt$8("isParameters");
}
/**
 * @internal
 */
function isReturn() {
    halt$8("isReturn");
}
/**
 * @internal
 */
function equalsFunction() {
    halt$8("equalsFunction");
}
/**
 * @internal
 */
function equalsParameters() {
    halt$8("equalsParameters");
}
/**
 * @internal
 */
function equalsReturn() {
    halt$8("equalsReturn");
}
/**
 * @internal
 */
function validateFunction() {
    halt$8("validateFunction");
}
/**
 * @internal
 */
function validateParameters() {
    halt$8("validateReturn");
}
/**
 * @internal
 */
function validateReturn() {
    halt$8("validateReturn");
}
/**
 * @internal
 */
function validateEqualsFunction() {
    halt$8("validateEqualsFunction");
}
/**
 * @internal
 */
function validateEqualsParameters() {
    halt$8("validateEqualsParameters");
}
/**
 * @internal
 */
function validateEqualsReturn() {
    halt$8("validateEqualsReturn");
}
/* -----------------------------------------------------------
  HALTER
----------------------------------------------------------- */
/**
 * @internal
 */
function halt$8(name) {
    throw new Error(`Error on typia.functional.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
}

var functional = /*#__PURE__*/Object.freeze({
  __proto__: null,
  assertEqualsFunction: assertEqualsFunction,
  assertEqualsParameters: assertEqualsParameters,
  assertEqualsReturn: assertEqualsReturn,
  assertFunction: assertFunction,
  assertParameters: assertParameters,
  assertReturn: assertReturn,
  equalsFunction: equalsFunction,
  equalsParameters: equalsParameters,
  equalsReturn: equalsReturn,
  isFunction: isFunction,
  isParameters: isParameters,
  isReturn: isReturn,
  validateEqualsFunction: validateEqualsFunction,
  validateEqualsParameters: validateEqualsParameters,
  validateEqualsReturn: validateEqualsReturn,
  validateFunction: validateFunction,
  validateParameters: validateParameters,
  validateReturn: validateReturn
});

/**
 * @internal
 */
function formData() {
    halt$7("formData");
}
/**
 * @internal
 */
function assertFormData() {
    halt$7("assertFormData");
}
/**
 * @internal
 */
function isFormData() {
    halt$7("isFormData");
}
/**
 * @internal
 */
function validateFormData() {
    halt$7("validateFormData");
}
/**
 * @internal
 */
function query() {
    halt$7("query");
}
/**
 * @internal
 */
function assertQuery() {
    halt$7("assertQuery");
}
/**
 * @internal
 */
function isQuery() {
    halt$7("isQuery");
}
/**
 * @internal
 */
function validateQuery() {
    halt$7("validateQuery");
}
/**
 * @internal
 */
function headers() {
    halt$7("headers");
}
/**
 * @internal
 */
function assertHeaders() {
    halt$7("assertHeaders");
}
/**
 * @internal
 */
function isHeaders() {
    halt$7("isHeaders");
}
/**
 * @internal
 */
function validateHeaders() {
    halt$7("validateHeaders");
}
/**
 * @internal
 */
function parameter() {
    halt$7("parameter");
}
/**
 * @internal
 */
function createFormData() {
    halt$7("createFormData");
}
/**
 * @internal
 */
function createAssertFormData() {
    halt$7("createAssertFormData");
}
/**
 * @internal
 */
function createIsFormData() {
    halt$7("createIsFormData");
}
/**
 * @internal
 */
function createValidateFormData() {
    halt$7("createValidateFormData");
}
/**
 * @internal
 */
function createQuery() {
    halt$7("createQuery");
}
/**
 * @internal
 */
function createAssertQuery() {
    halt$7("createAssertQuery");
}
/**
 * @internal
 */
function createIsQuery() {
    halt$7("createIsQuery");
}
/**
 * @internal
 */
function createValidateQuery() {
    halt$7("createValidateQuery");
}
/**
 * @internal
 */
function createHeaders() {
    halt$7("createHeaders");
}
/**
 * @internal
 */
function createAssertHeaders() {
    halt$7("createAssertHeaders");
}
/**
 * @internal
 */
function createIsHeaders() {
    halt$7("createIsHeaders");
}
/**
 * @internal
 */
function createValidateHeaders() {
    halt$7("createValidateHeaders");
}
/**
 * @internal
 */
function createParameter() {
    halt$7("createParameter");
}
/**
 * @internal
 */
function halt$7(name) {
    throw new Error(`Error on typia.http.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
}

var http = /*#__PURE__*/Object.freeze({
  __proto__: null,
  assertFormData: assertFormData,
  assertHeaders: assertHeaders,
  assertQuery: assertQuery,
  createAssertFormData: createAssertFormData,
  createAssertHeaders: createAssertHeaders,
  createAssertQuery: createAssertQuery,
  createFormData: createFormData,
  createHeaders: createHeaders,
  createIsFormData: createIsFormData,
  createIsHeaders: createIsHeaders,
  createIsQuery: createIsQuery,
  createParameter: createParameter,
  createQuery: createQuery,
  createValidateFormData: createValidateFormData,
  createValidateHeaders: createValidateHeaders,
  createValidateQuery: createValidateQuery,
  formData: formData,
  headers: headers,
  isFormData: isFormData,
  isHeaders: isHeaders,
  isQuery: isQuery,
  parameter: parameter,
  query: query,
  validateFormData: validateFormData,
  validateHeaders: validateHeaders,
  validateQuery: validateQuery
});

/**
 * @internal
 */
function application$1() {
    halt$6("application");
}
/**
 * @internal
 */
function parameters() {
    halt$6("parameters");
}
/**
 * @internal
 */
function schema() {
    halt$6("schema");
}
/**
 * @internal
 */
function halt$6(name) {
    throw new Error(`Error on typia.llm.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
}

var llm = /*#__PURE__*/Object.freeze({
  __proto__: null,
  application: application$1,
  parameters: parameters,
  schema: schema
});

/**
 * @internal
 */
function schemas() {
    halt$5("schemas");
}
/**
 * @internal
 */
function application() {
    halt$5("application");
}
/**
 * @internal
 */
function assertParse() {
    halt$5("assertParse");
}
/**
 * @internal
 */
function isParse() {
    halt$5("isParse");
}
/**
 * @internal
 */
function validateParse() {
    halt$5("validateParse");
}
/**
 * @internal
 */
function stringify() {
    halt$5("stringify");
}
/**
 * @internal
 */
function assertStringify() {
    halt$5("assertStringify");
}
/**
 * @internal
 */
function isStringify() {
    halt$5("isStringify");
}
/**
 * @internal
 */
function validateStringify() {
    halt$5("validateStringify");
}
/**
 * @internal
 */
function createIsParse() {
    halt$5("createIsParse");
}
/**
 * @internal
 */
function createAssertParse() {
    halt$5("createAssertParse");
}
/**
 * @internal
 */
function createValidateParse() {
    halt$5("createValidateParse");
}
/**
 * @internal
 */
function createStringify() {
    halt$5("createStringify");
}
/**
 * @internal
 */
function createAssertStringify() {
    halt$5("createAssertStringify");
}
/**
 * @internal
 */
function createIsStringify() {
    halt$5("createIsStringify");
}
/**
 * @internal
 */
function createValidateStringify() {
    halt$5("createValidateStringify");
}
/**
 * @internal
 */
function halt$5(name) {
    throw new Error(`Error on typia.json.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
}

var json = /*#__PURE__*/Object.freeze({
  __proto__: null,
  application: application,
  assertParse: assertParse,
  assertStringify: assertStringify,
  createAssertParse: createAssertParse,
  createAssertStringify: createAssertStringify,
  createIsParse: createIsParse,
  createIsStringify: createIsStringify,
  createStringify: createStringify,
  createValidateParse: createValidateParse,
  createValidateStringify: createValidateStringify,
  isParse: isParse,
  isStringify: isStringify,
  schemas: schemas,
  stringify: stringify,
  validateParse: validateParse,
  validateStringify: validateStringify
});

/**
 * @internal
 */
function literals() {
    halt$4("literals");
}
/**
 * @internal
 */
function clone() {
    halt$4("clone");
}
/**
 * @internal
 */
function assertClone() {
    halt$4("assertClone");
}
/**
 * @internal
 */
function isClone() {
    halt$4("isClone");
}
/**
 * @internal
 */
function validateClone() {
    halt$4("validateClone");
}
/**
 * @internal
 */
function prune() {
    halt$4("prune");
}
/**
 * @internal
 */
function assertPrune() {
    halt$4("assertPrune");
}
/**
 * @internal
 */
function isPrune() {
    halt$4("isPrune");
}
/**
 * @internal
 */
function validatePrune() {
    halt$4("validatePrune");
}
/**
 * @internal
 */
function createClone() {
    halt$4("createClone");
}
/**
 * @internal
 */
function createAssertClone() {
    halt$4("createAssertClone");
}
/**
 * @internal
 */
function createIsClone() {
    halt$4("createIsClone");
}
/**
 * @internal
 */
function createValidateClone() {
    halt$4("createValidateClone");
}
/**
 * @internal
 */
function createPrune() {
    halt$4("createPrune");
}
/**
 * @internal
 */
function createAssertPrune() {
    halt$4("createAssertPrune");
}
/**
 * @internal
 */
function createIsPrune() {
    halt$4("createIsPrune");
}
/**
 * @internal
 */
function createValidatePrune() {
    halt$4("createValidatePrune");
}
/**
 * @internal
 */
function halt$4(name) {
    throw new Error(`Error on typia.misc.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
}

var misc = /*#__PURE__*/Object.freeze({
  __proto__: null,
  assertClone: assertClone,
  assertPrune: assertPrune,
  clone: clone,
  createAssertClone: createAssertClone,
  createAssertPrune: createAssertPrune,
  createClone: createClone,
  createIsClone: createIsClone,
  createIsPrune: createIsPrune,
  createPrune: createPrune,
  createValidateClone: createValidateClone,
  createValidatePrune: createValidatePrune,
  isClone: isClone,
  isPrune: isPrune,
  literals: literals,
  prune: prune,
  validateClone: validateClone,
  validatePrune: validatePrune
});

/**
 * @internal
 */
function camel() {
    return halt$3("camel");
}
/**
 * @internal
 */
function assertCamel() {
    return halt$3("assertCamel");
}
/**
 * @internal
 */
function isCamel() {
    return halt$3("isCamel");
}
/**
 * @internal
 */
function validateCamel() {
    return halt$3("validateCamel");
}
/**
 * @internal
 */
function pascal() {
    return halt$3("pascal");
}
/**
 * @internal
 */
function assertPascal() {
    return halt$3("assertPascal");
}
/**
 * @internal
 */
function isPascal() {
    return halt$3("isPascal");
}
/**
 * @internal
 */
function validatePascal() {
    return halt$3("validatePascal");
}
/**
 * @internal
 */
function snake() {
    return halt$3("snake");
}
/**
 * @internal
 */
function assertSnake() {
    return halt$3("assertSnake");
}
/**
 * @internal
 */
function isSnake() {
    return halt$3("isSnake");
}
/**
 * @internal
 */
function validateSnake() {
    return halt$3("validateSnake");
}
/**
 * @internal
 */
function createCamel() {
    halt$3("createCamel");
}
/**
 * @internal
 */
function createAssertCamel() {
    halt$3("createAssertCamel");
}
/**
 * @internal
 */
function createIsCamel() {
    halt$3("createIsCamel");
}
/**
 * @internal
 */
function createValidateCamel() {
    halt$3("createValidateCamel");
}
/**
 * @internal
 */
function createPascal() {
    halt$3("createPascal");
}
/**
 * @internal
 */
function createAssertPascal() {
    halt$3("createAssertPascal");
}
/**
 * @internal
 */
function createIsPascal() {
    halt$3("createIsPascal");
}
/**
 * @internal
 */
function createValidatePascal() {
    halt$3("createValidatePascal");
}
/**
 * @internal
 */
function createSnake() {
    halt$3("createSnake");
}
/**
 * @internal
 */
function createAssertSnake() {
    halt$3("createAssertSnake");
}
/**
 * @internal
 */
function createIsSnake() {
    halt$3("createIsSnake");
}
/**
 * @internal
 */
function createValidateSnake() {
    halt$3("createValidateSnake");
}
/**
 * @internal
 */
function halt$3(name) {
    throw new Error(`Error on typia.notations.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
}

var notations = /*#__PURE__*/Object.freeze({
  __proto__: null,
  assertCamel: assertCamel,
  assertPascal: assertPascal,
  assertSnake: assertSnake,
  camel: camel,
  createAssertCamel: createAssertCamel,
  createAssertPascal: createAssertPascal,
  createAssertSnake: createAssertSnake,
  createCamel: createCamel,
  createIsCamel: createIsCamel,
  createIsPascal: createIsPascal,
  createIsSnake: createIsSnake,
  createPascal: createPascal,
  createSnake: createSnake,
  createValidateCamel: createValidateCamel,
  createValidatePascal: createValidatePascal,
  createValidateSnake: createValidateSnake,
  isCamel: isCamel,
  isPascal: isPascal,
  isSnake: isSnake,
  pascal: pascal,
  snake: snake,
  validateCamel: validateCamel,
  validatePascal: validatePascal,
  validateSnake: validateSnake
});

/**
 * @internal
 */
function message() {
    halt$2("message");
}
/**
 * @internal
 */
function decode() {
    halt$2("decode");
}
/**
 * @internal
 */
function assertDecode() {
    halt$2("assertDecode");
}
/**
 * @internal
 */
function isDecode() {
    halt$2("isDecode");
}
/**
 * @internal
 */
function validateDecode() {
    halt$2("validateDecode");
}
/**
 * @internal
 */
function encode() {
    halt$2("encode");
}
/**
 * @internal
 */
function assertEncode() {
    halt$2("assertEncode");
}
/**
 * @internal
 */
function isEncode() {
    halt$2("isEncode");
}
/**
 * @internal
 */
function validateEncode() {
    halt$2("validateEncode");
}
/**
 * @internal
 */
function createDecode() {
    halt$2("createDecode");
}
/**
 * @internal
 */
function createIsDecode() {
    halt$2("createIsDecode");
}
/**
 * @internal
 */
function createAssertDecode() {
    halt$2("createAssertDecode");
}
/**
 * @internal
 */
function createValidateDecode() {
    halt$2("createValidateDecode");
}
/**
 * @internal
 */
function createEncode() {
    halt$2("createEncode");
}
/**
 * @internal
 */
function createIsEncode() {
    halt$2("createIsEncode");
}
/**
 * @internal
 */
function createAssertEncode() {
    halt$2("createAssertEncode");
}
/**
 * @internal
 */
function createValidateEncode() {
    halt$2("createValidateEncode");
}
/**
 * @internal
 */
function halt$2(name) {
    throw new Error(`Error on typia.protobuf.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
}

var protobuf = /*#__PURE__*/Object.freeze({
  __proto__: null,
  assertDecode: assertDecode,
  assertEncode: assertEncode,
  createAssertDecode: createAssertDecode,
  createAssertEncode: createAssertEncode,
  createDecode: createDecode,
  createEncode: createEncode,
  createIsDecode: createIsDecode,
  createIsEncode: createIsEncode,
  createValidateDecode: createValidateDecode,
  createValidateEncode: createValidateEncode,
  decode: decode,
  encode: encode,
  isDecode: isDecode,
  isEncode: isEncode,
  message: message,
  validateDecode: validateDecode,
  validateEncode: validateEncode
});

/**
 * @internal
 */
function metadata() {
    halt$1("metadata");
}
function name() {
    halt$1("name");
}
/**
 * @internal
 */
function halt$1(name) {
    throw new Error(`Error on typia.reflect.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
}

var reflect = /*#__PURE__*/Object.freeze({
  __proto__: null,
  metadata: metadata,
  name: name
});

var index = /*#__PURE__*/Object.freeze({
  __proto__: null
});

class TypeGuardError extends Error {
    method;
    path;
    expected;
    value;
    fake_expected_typed_value_;
    constructor(props) {
        // MESSAGE CONSTRUCTION
        super(props.message ||
            `Error on ${props.method}(): invalid type${props.path ? ` on ${props.path}` : ""}, expect to be ${props.expected}`);
        // INHERITANCE POLYFILL
        const proto = new.target.prototype;
        if (Object.setPrototypeOf)
            Object.setPrototypeOf(this, proto);
        else
            this.__proto__ = proto;
        // ASSIGN MEMBERS
        this.method = props.method;
        this.path = props.path;
        this.expected = props.expected;
        this.value = props.value;
    }
}

/**
 * @internal
 */
function assert() {
    halt("assert");
}
/**
 * @internal
 */
function assertGuard() {
    halt("assertGuard");
}
/**
 * @internal
 */
function is() {
    halt("is");
}
/**
 * @internal
 */
function validate() {
    halt("validate");
}
/**
 * @internal
 */
function assertEquals() {
    halt("assertEquals");
}
/**
 * @internal
 */
function assertGuardEquals() {
    halt("assertGuardEquals");
}
/**
 * @internal
 */
function equals() {
    halt("equals");
}
/**
 * @internal
 */
function validateEquals() {
    halt("validateEquals");
}
/**
 * @internal
 */
function random() {
    halt("random");
}
/**
 * @internal
 */
function createAssert() {
    halt("createAssert");
}
/**
 * @internal
 */
function createAssertGuard() {
    halt("createAssertGuard");
}
/**
 * @internal
 */
function createIs() {
    halt("createIs");
}
/**
 * @internal
 */
function createValidate() {
    halt("createValidate");
}
/**
 * @internal
 */
function createAssertEquals() {
    halt("createAssertEquals");
}
/**
 * @internal
 */
function createAssertGuardEquals() {
    halt("createAssertGuardEquals");
}
/**
 * @internal
 */
function createEquals() {
    halt("createEquals");
}
/**
 * @internal
 */
function createValidateEquals() {
    halt("createValidateEquals");
}
/**
 * @internal
 */
function createRandom() {
    halt("createRandom");
}
/**
 * @internal
 */
function halt(name) {
    throw new Error(`Error on typia.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
}

var typia = /*#__PURE__*/Object.freeze({
  __proto__: null,
  TypeGuardError: TypeGuardError,
  assert: assert,
  assertEquals: assertEquals,
  assertGuard: assertGuard,
  assertGuardEquals: assertGuardEquals,
  createAssert: createAssert,
  createAssertEquals: createAssertEquals,
  createAssertGuard: createAssertGuard,
  createAssertGuardEquals: createAssertGuardEquals,
  createEquals: createEquals,
  createIs: createIs,
  createRandom: createRandom,
  createValidate: createValidate,
  createValidateEquals: createValidateEquals,
  equals: equals,
  functional: functional,
  http: http,
  is: is,
  json: json,
  llm: llm,
  misc: misc,
  notations: notations,
  protobuf: protobuf,
  random: random,
  reflect: reflect,
  tags: index,
  validate: validate,
  validateEquals: validateEquals
});

export { TypeGuardError, assert, assertEquals, assertGuard, assertGuardEquals, createAssert, createAssertEquals, createAssertGuard, createAssertGuardEquals, createEquals, createIs, createRandom, createValidate, createValidateEquals, typia as default, equals, functional, http, is, json, llm, misc, notations, protobuf, random, reflect, index as tags, validate, validateEquals };
//# sourceMappingURL=index.mjs.map