typia 13.1.1 → 13.2.0

package/src/functional.ts

@@ -3,6 +3,24 @@ import { IValidation } from "@typia/interface";
 import { TypeGuardError } from "./TypeGuardError";
 import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError";
 
+type FunctionalIs<T extends (...args: any[]) => any> = T extends (
+  this: infer This,
+  ...args: infer Arguments
+) => infer Output
+  ? Output extends Promise<infer R>
+    ? (this: This, ...args: Arguments) => Promise<R | null>
+    : (this: This, ...args: Arguments) => Output | null
+  : never;
+
+type FunctionalValidate<T extends (...args: any[]) => any> = T extends (
+  this: infer This,
+  ...args: infer Arguments
+) => infer Output
+  ? Output extends Promise<infer R>
+    ? (this: This, ...args: Arguments) => Promise<IValidation<R>>
+    : (this: This, ...args: Arguments) => IValidation<Output>
+  : never;
+
 /* ===========================================================
   FUNCTIONAL
     - ASSERT
@@ -232,11 +250,7 @@ export function assertEqualsReturn(): never {
  */
 export function isFunction<T extends (...args: any[]) => any>(
   func: T,
-): T extends (...args: infer Arguments) => infer Output
-  ? Output extends Promise<infer R>
-    ? (...args: Arguments) => Promise<R | null>
-    : (...args: Arguments) => Output | null
-  : never;
+): FunctionalIs<T>;
 
 /** @internal */
 export function isFunction(): never {
@@ -263,11 +277,7 @@ export function isFunction(): never {
  */
 export function isParameters<T extends (...args: any[]) => any>(
   func: T,
-): T extends (...args: infer Arguments) => infer Output
-  ? Output extends Promise<infer R>
-    ? (...args: Arguments) => Promise<R | null>
-    : (...args: Arguments) => Output | null
-  : never;
+): FunctionalIs<T>;
 
 /** @internal */
 export function isParameters(): never {
@@ -294,11 +304,7 @@ export function isParameters(): never {
  */
 export function isReturn<T extends (...args: any[]) => any>(
   func: T,
-): T extends (...args: infer Arguments) => infer Output
-  ? Output extends Promise<infer R>
-    ? (...args: Arguments) => Promise<R | null>
-    : (...args: Arguments) => Output | null
-  : never;
+): FunctionalIs<T>;
 
 /** @internal */
 export function isReturn(): never {
@@ -325,11 +331,7 @@ export function isReturn(): never {
  */
 export function equalsFunction<T extends (...args: any[]) => any>(
   func: T,
-): T extends (...args: infer Arguments) => infer Output
-  ? Output extends Promise<infer R>
-    ? (...args: Arguments) => Promise<R | null>
-    : (...args: Arguments) => Output | null
-  : never;
+): FunctionalIs<T>;
 
 /** @internal */
 export function equalsFunction(): never {
@@ -356,11 +358,7 @@ export function equalsFunction(): never {
  */
 export function equalsParameters<T extends (...args: any[]) => any>(
   func: T,
-): T extends (...args: infer Arguments) => infer Output
-  ? Output extends Promise<infer R>
-    ? (...args: Arguments) => Promise<R | null>
-    : (...args: Arguments) => Output | null
-  : never;
+): FunctionalIs<T>;
 
 /** @internal */
 export function equalsParameters(): never {
@@ -387,11 +385,7 @@ export function equalsParameters(): never {
  */
 export function equalsReturn<T extends (...args: any[]) => any>(
   func: T,
-): T extends (...args: infer Arguments) => infer Output
-  ? Output extends Promise<infer R>
-    ? (...args: Arguments) => Promise<R | null>
-    : (...args: Arguments) => Output | null
-  : never;
+): FunctionalIs<T>;
 
 /** @internal */
 export function equalsReturn(): never {
@@ -425,11 +419,7 @@ export function equalsReturn(): never {
  */
 export function validateFunction<T extends (...args: any[]) => any>(
   func: T,
-): T extends (...args: infer Arguments) => infer Output
-  ? Output extends Promise<infer R>
-    ? (...args: Arguments) => Promise<IValidation<R>>
-    : (...args: Arguments) => IValidation<Output>
-  : never;
+): FunctionalValidate<T>;
 
 /** @internal */
 export function validateFunction(): never {
@@ -457,11 +447,7 @@ export function validateFunction(): never {
  */
 export function validateParameters<T extends (...args: any[]) => any>(
   func: T,
-): T extends (...args: infer Arguments) => infer Output
-  ? Output extends Promise<infer R>
-    ? (...args: Arguments) => Promise<IValidation<R>>
-    : (...args: Arguments) => IValidation<Output>
-  : never;
+): FunctionalValidate<T>;
 
 /** @internal */
 export function validateParameters(): never {
@@ -489,11 +475,7 @@ export function validateParameters(): never {
  */
 export function validateReturn<T extends (...args: any[]) => any>(
   func: T,
-): T extends (...args: infer Arguments) => infer Output
-  ? Output extends Promise<infer R>
-    ? (...args: Arguments) => Promise<IValidation<R>>
-    : (...args: Arguments) => IValidation<Output>
-  : never;
+): FunctionalValidate<T>;
 
 /** @internal */
 export function validateReturn(): never {
@@ -524,11 +506,7 @@ export function validateReturn(): never {
  */
 export function validateEqualsFunction<T extends (...args: any[]) => any>(
   func: T,
-): T extends (...args: infer Arguments) => infer Output
-  ? Output extends Promise<infer R>
-    ? (...args: Arguments) => Promise<IValidation<R>>
-    : (...args: Arguments) => IValidation<Output>
-  : never;
+): FunctionalValidate<T>;
 
 /** @internal */
 export function validateEqualsFunction(): never {
@@ -556,11 +534,7 @@ export function validateEqualsFunction(): never {
  */
 export function validateEqualsParameters<T extends (...args: any[]) => any>(
   func: T,
-): T extends (...args: infer Arguments) => infer Output
-  ? Output extends Promise<infer R>
-    ? (...args: Arguments) => Promise<IValidation<R>>
-    : (...args: Arguments) => IValidation<Output>
-  : never;
+): FunctionalValidate<T>;
 
 /** @internal */
 export function validateEqualsParameters(): never {
@@ -588,11 +562,7 @@ export function validateEqualsParameters(): never {
  */
 export function validateEqualsReturn<T extends (...args: any[]) => any>(
   func: T,
-): T extends (...args: infer Arguments) => infer Output
-  ? Output extends Promise<infer R>
-    ? (...args: Arguments) => Promise<IValidation<R>>
-    : (...args: Arguments) => IValidation<Output>
-  : never;
+): FunctionalValidate<T>;
 
 /** @internal */
 export function validateEqualsReturn(): never {

package/src/internal/_ProtobufReader.ts

@@ -12,10 +12,14 @@ export class _ProtobufReader {
   /** DataView for buffer. */
   private view: DataView;
 
+  /** Current length-delimited boundary. */
+  private end: number;
+
   public constructor(buf: Uint8Array) {
     this.buf = buf;
     this.ptr = 0;
     this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    this.end = buf.length;
   }
 
   public index(): number {
@@ -23,7 +27,7 @@ export class _ProtobufReader {
   }
 
   public size(): number {
-    return this.buf.length;
+    return this.end;
   }
 
   public uint32(): number {
@@ -44,7 +48,7 @@ export class _ProtobufReader {
   }
 
   public int64(): bigint {
-    return this.varint64();
+    return BigInt.asIntN(64, this.varint64());
   }
 
   public sint64(): bigint {
@@ -57,58 +61,94 @@ export class _ProtobufReader {
   }
 
   public float(): number {
-    const value: number = this.view.getFloat32(this.ptr, true);
-    this.ptr += 4;
-    return value;
+    return this.view.getFloat32(this.take(4), true);
   }
 
   public double(): number {
-    const value: number = this.view.getFloat64(this.ptr, true);
-    this.ptr += 8;
-    return value;
+    return this.view.getFloat64(this.take(8), true);
   }
 
   public bytes(): Uint8Array {
-    const length: number = this.uint32();
-    const from: number = this.ptr;
-    this.ptr += length;
-    return this.buf.subarray(from, from + length);
+    return this.atomic(() => {
+      const length: number = this.uint32();
+      const from: number = this.take(length);
+      return this.buf.subarray(from, from + length);
+    });
   }
 
   public string(): string {
-    return utf8.get().decode(this.bytes());
+    const bytes: Uint8Array = this.bytes();
+    const decoder: TextDecoder = utf8.get();
+    try {
+      return decoder.decode(bytes);
+    } catch {
+      throw error("invalid UTF-8 string.");
+    }
   }
 
+  public fork(): number {
+    return this.atomic(() => {
+      const previous: number = this.end;
+      const length: number = this.uint32();
+      this.validate(length);
+      this.end = this.ptr + length;
+      return previous;
+    });
+  }
+
+  public close(previous: number): void {
+    if (this.ptr !== this.end) throw error("buffer overflow.");
+    this.end = previous;
+  }
+
+  /** Advance by exactly `length` bytes, for every length including zero. */
   public skip(length: number): void {
-    if (length === 0) while (this.u8() & 0x80);
-    else {
-      if (this.index() + length > this.size())
-        throw new Error("Error on typia.protobuf.decode(): buffer overflow.");
-      this.ptr += length;
-    }
+    this.take(length);
+  }
+
+  /**
+   * Advance by exactly one varint, which carries no length prefix.
+   *
+   * A varint terminates at its first byte without the continuation bit, and may
+   * occupy no more than {@link VARINT_MAX_BYTES}. Its tenth byte is bounded
+   * twice over, by {@link lastVarintByte}: it may neither continue into an
+   * eleventh byte nor carry payload above bit 63. Skipping is where that is
+   * easiest to get wrong, because this path discards the bytes it reads and so
+   * never notices a value it could not have represented. Relaxing either bound
+   * here would accept a varint that `varint32` and `varint64` reject, making
+   * the limit depend on which method happens to consume the value.
+   */
+  public skipVarint(): void {
+    this.atomic(() => {
+      for (let i: number = 1; i < VARINT_MAX_BYTES; ++i)
+        if ((this.u8() & 0x80) === 0) return;
+      this.lastVarintByte();
+    });
   }
 
   public skipType(wireType: ProtobufWire): void {
-    switch (wireType) {
-      case ProtobufWire.VARIANT:
-        this.skip(0);
-        break;
-      case ProtobufWire.I64:
-        this.skip(8);
-        break;
-      case ProtobufWire.LEN:
-        this.skip(this.uint32());
-        break;
-      case ProtobufWire.START_GROUP:
-        while ((wireType = this.uint32() & 0x07) !== ProtobufWire.END_GROUP)
-          this.skipType(wireType);
-        break;
-      case ProtobufWire.I32:
-        this.skip(4);
-        break;
-      default:
-        throw new Error(`Invalid wire type ${wireType} at offset ${this.ptr}.`);
-    }
+    this.atomic(() => {
+      switch (wireType) {
+        case ProtobufWire.VARIANT:
+          this.skipVarint();
+          break;
+        case ProtobufWire.I64:
+          this.skip(8);
+          break;
+        case ProtobufWire.LEN:
+          this.skip(this.uint32());
+          break;
+        case ProtobufWire.START_GROUP:
+          while ((wireType = this.uint32() & 0x07) !== ProtobufWire.END_GROUP)
+            this.skipType(wireType);
+          break;
+        case ProtobufWire.I32:
+          this.skip(4);
+          break;
+        default:
+          throw error(`invalid wire type ${wireType} at offset ${this.ptr}.`);
+      }
+    });
   }
 
   private varint32(): number {
@@ -130,13 +170,13 @@ export class _ProtobufReader {
     value |= ((loaded = this.u8()) & 0xf) << 28;
     if (loaded < 0x80) return value;
 
-    // increment position until there is no continuation bit or until we read 10 bytes
-    if (this.u8() < 0x80) return value;
+    // increment position until there is no continuation bit, or until this read
+    // reaches VARINT_MAX_BYTES and the value can hold no further bits
     if (this.u8() < 0x80) return value;
     if (this.u8() < 0x80) return value;
     if (this.u8() < 0x80) return value;
     if (this.u8() < 0x80) return value;
-
+    this.lastVarintByte();
     return value;
   }
 
@@ -171,17 +211,92 @@ export class _ProtobufReader {
     value |= ((loaded = this.u8n()) & BigInt(0x7f)) << BigInt(56);
     if (loaded < BigInt(0x80)) return value;
 
-    value |= (this.u8n() & BigInt(0x01)) << BigInt(63);
-    return BigInt.asIntN(64, value);
+    value |= BigInt(this.lastVarintByte()) << BigInt(63);
+    return BigInt.asUintN(64, value);
+  }
+
+  /**
+   * Read the only byte whose varint payload is limited to bit 63.
+   *
+   * Two distinct faults meet on this byte, and each is named for what it is. A
+   * continuation bit means the varint would occupy an eleventh byte, which no
+   * 64-bit value can reach. Any other payload bit means the varint terminates
+   * within its ten bytes but carries a value bit above 63. Reporting the second
+   * as a length fault would tell the caller something untrue about a payload
+   * that is exactly ten bytes long.
+   */
+  private lastVarintByte(): number {
+    const loaded: number = this.u8();
+    if ((loaded & 0x80) !== 0)
+      throw error(`varint exceeds ${VARINT_MAX_BYTES} bytes.`);
+    if (loaded > 0x01) throw error(`varint exceeds ${VARINT_MAX_BITS} bits.`);
+    return loaded;
   }
 
   private u8(): number {
-    return this.view.getUint8(this.ptr++);
+    return this.view.getUint8(this.take(1));
   }
 
   private u8n(): bigint {
     return BigInt(this.u8());
   }
+
+  private take(length: number): number {
+    this.validate(length);
+    const from: number = this.ptr;
+    this.ptr += length;
+    return from;
+  }
+
+  private atomic<T>(closure: () => T): T {
+    const index: number = this.ptr;
+    const end: number = this.end;
+    try {
+      return closure();
+    } catch (thrown) {
+      this.ptr = index;
+      this.end = end;
+      throw thrown;
+    }
+  }
+
+  private validate(length: number): void {
+    if (
+      Number.isSafeInteger(length) === false ||
+      length < 0 ||
+      length > this.size() - this.ptr
+    )
+      throw error("buffer overflow.");
+  }
 }
 
-const utf8 = new Singleton(() => new TextDecoder("utf-8"));
+/**
+ * Builds every fault this reader raises, so each one names typia as its source.
+ *
+ * Every decode error a caller can see must be attributable, and the prefix is
+ * what attributes it. Composing it here rather than at each throw keeps a new
+ * fault from silently shipping without it.
+ */
+const error = (message: string): Error =>
+  new Error(`Error on typia.protobuf.decode(): ${message}`);
+
+/**
+ * The most bytes a varint may occupy: a 64-bit value in seven-bit groups.
+ *
+ * Every path reads no further than its tenth byte and accepts only bit 63 from
+ * that byte. This constant keeps the loop-driven skip path on the same limit.
+ */
+const VARINT_MAX_BYTES = 10;
+
+/**
+ * The widest value a varint may carry: the 64-bit Protocol Buffer wire domain.
+ *
+ * The tenth byte reaches only bit 63, so a payload bit above it belongs to no
+ * representable value. This names the overflow fault apart from the length
+ * one.
+ */
+const VARINT_MAX_BITS = 64;
+
+const utf8 = new Singleton(
+  () => new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }),
+);

package/src/internal/_createStandardSchema.ts

@@ -17,7 +17,7 @@ export const _createStandardSchema = <T>(
         } else {
           return {
             issues: result.errors.map((error) => ({
-              message: `expected ${error.expected}, got ${error.value}`,
+              message: `expected ${error.expected}, got ${formatValue(error.value)}`,
               path: typiaPathToStandardSchemaPath(error.path),
             })),
           } satisfies StandardSchemaV1.FailureResult;
@@ -26,6 +26,20 @@ export const _createStandardSchema = <T>(
     },
   } satisfies StandardSchemaV1<T, T>);
 
+const formatValue = (value: unknown): string => {
+  if (typeof value === "object") {
+    if (value === null) return "null";
+    try {
+      if (Array.isArray(value)) return "[object Array]";
+    } catch {
+      // A revoked proxy can throw even for Array.isArray().
+    }
+    return "[object Object]";
+  }
+  if (typeof value === "function") return "[function]";
+  return String(value);
+};
+
 enum PathParserState {
   // Start of a new segment
   // When the parser is in this state,

package/src/internal/_decimal.ts

@@ -0,0 +1,69 @@
+export interface _IDecimal {
+  coefficient: bigint;
+  exponent: number;
+}
+
+export interface _IDecimalRatio {
+  numerator: bigint;
+  denominator: bigint;
+}
+
+export const _decimalDecompose = (value: number): _IDecimal | null => {
+  if (Number.isFinite(value) === false) return null;
+  const [mantissa = "0", exponentText = "0"] = value.toString().split("e");
+  const negative: boolean = mantissa.startsWith("-");
+  const unsigned: string = negative ? mantissa.slice(1) : mantissa;
+  const point: number = unsigned.indexOf(".");
+  const decimals: number = point === -1 ? 0 : unsigned.length - point - 1;
+  const digits: bigint = BigInt(unsigned.replace(".", ""));
+  return {
+    coefficient: negative ? -digits : digits,
+    exponent: Number(exponentText) - decimals,
+  };
+};
+
+export const _decimalDivide = (
+  value: number,
+  divisor: _IDecimal,
+): _IDecimalRatio | null => {
+  const dividend: _IDecimal | null = _decimalDecompose(value);
+  if (dividend === null || divisor.coefficient === BigInt(0)) return null;
+  const exponent: number = dividend.exponent - divisor.exponent;
+  return exponent >= 0
+    ? {
+        numerator: dividend.coefficient * _decimalPower(exponent),
+        denominator: divisor.coefficient,
+      }
+    : {
+        numerator: dividend.coefficient,
+        denominator: divisor.coefficient * _decimalPower(-exponent),
+      };
+};
+
+export const _decimalIntegerStep = (value: number): _IDecimal | null => {
+  const decimal: _IDecimal | null = _decimalDecompose(value);
+  if (decimal === null || decimal.coefficient <= BigInt(0)) return null;
+  if (decimal.exponent >= 0)
+    return {
+      coefficient: decimal.coefficient * _decimalPower(decimal.exponent),
+      exponent: 0,
+    };
+
+  const denominator: bigint = _decimalPower(-decimal.exponent);
+  return {
+    coefficient:
+      decimal.coefficient / _decimalGcd(decimal.coefficient, denominator),
+    exponent: 0,
+  };
+};
+
+export const _decimalToNumber = (value: _IDecimal): number =>
+  Number(`${value.coefficient}e${value.exponent}`);
+
+export const _decimalPower = (exponent: number): bigint =>
+  BigInt(10) ** BigInt(exponent);
+
+export const _decimalGcd = (x: bigint, y: bigint): bigint => {
+  while (y !== BigInt(0)) [x, y] = [y, x % y];
+  return x < BigInt(0) ? -x : x;
+};

package/src/internal/_httpQueryParseURLSearchParams.ts

@@ -4,9 +4,31 @@ export const _httpQueryParseURLSearchParams = (
   input: string | IReadableURLSearchParams,
 ): IReadableURLSearchParams => {
   if (typeof input === "string") {
-    const index: number = input.indexOf("?");
-    input = index === -1 ? "" : input.substring(index + 1);
+    let url: boolean = false;
+    if (input.startsWith("?")) {
+      input = input.substring(1);
+      url = true;
+    } else {
+      const index: number = input.indexOf("?");
+      if (index !== -1 && isUrlPrefix(input.substring(0, index))) {
+        input = input.substring(index + 1);
+        url = true;
+      } else if (index === -1 && isExplicitUrlPrefix(input)) {
+        input = "";
+        url = true;
+      }
+    }
+    if (url) {
+      const fragment: number = input.indexOf("#");
+      if (fragment !== -1) input = input.substring(0, fragment);
+    }
     return new URLSearchParams(input);
   }
   return input;
 };
+
+const isUrlPrefix = (prefix: string): boolean =>
+  isExplicitUrlPrefix(prefix) || (prefix.length !== 0 && !/[=&]/.test(prefix));
+
+const isExplicitUrlPrefix = (prefix: string): boolean =>
+  /^[a-z][a-z\d+.-]*:/i.test(prefix) || /^(?:\/\/|\/|\.{1,2}\/)/.test(prefix);

package/src/internal/_isFormatByte.ts

@@ -1,7 +1,4 @@
-export const _isFormatByte = (str: string): boolean => {
-  PATTERN.lastIndex = 0;
-  return PATTERN.test(str);
-};
+export const _isFormatByte = (str: string): boolean => PATTERN.test(str);
 
 const PATTERN =
-  /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
+  /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;

package/src/internal/_isFormatDate.ts

@@ -1,3 +1,16 @@
-export const _isFormatDate = (str: string): boolean => FORMAT.test(str);
+export const _isFormatDate = (str: string): boolean => {
+  const match: RegExpExecArray | null = PATTERN.exec(str);
+  if (match === null) return false;
+  const year: number = Number(match[1]);
+  const month: number = Number(match[2]);
+  const day: number = Number(match[3]);
+  const maximum: number =
+    DAYS[month - 1]! +
+    (month === 2 && (year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0))
+      ? 1
+      : 0);
+  return day <= maximum;
+};
 
-const FORMAT = /^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/;
+const PATTERN = /^([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/;
+const DAYS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] as const;

package/src/internal/_isFormatDateTime.ts

@@ -1,4 +1,30 @@
-export const _isFormatDateTime = (str: string): boolean => PATTERN.test(str);
+import { _isFormatDate } from "./_isFormatDate";
+
+export const _isFormatDateTime = (str: string): boolean => {
+  const match: RegExpExecArray | null = PATTERN.exec(str);
+  if (match === null || _isFormatDate(match[1]!) === false) return false;
+  if (match[7] !== "60") return true;
+
+  const instant: Date = new Date(0);
+  instant.setUTCFullYear(
+    Number(match[2]),
+    Number(match[3]) - 1,
+    Number(match[4]),
+  );
+  instant.setUTCHours(Number(match[5]), Number(match[6]), 0, 0);
+  const offset: number =
+    match[8] === undefined
+      ? 0
+      : (match[8] === "+" ? 1 : -1) *
+        (Number(match[9]) * 60 + Number(match[10]));
+  instant.setUTCMinutes(instant.getUTCMinutes() - offset);
+  return (
+    instant.getUTCHours() === 23 &&
+    instant.getUTCMinutes() === 59 &&
+    ((instant.getUTCMonth() === 5 && instant.getUTCDate() === 30) ||
+      (instant.getUTCMonth() === 11 && instant.getUTCDate() === 31))
+  );
+};
 
 const PATTERN =
-  /^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])(T|\s)([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:\.[0-9]{1,9})?(Z|[+-]([01][0-9]|2[0-3]):[0-5][0-9])$/i;
+  /^(([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01]))[Tt]((?:[01][0-9]|2[0-3])):([0-5][0-9]):([0-5][0-9]|60)(?:\.[0-9]+)?(?:[Zz]|([+-])((?:[01][0-9]|2[0-3])):([0-5][0-9]))$/;

package/src/internal/_isFormatIri.ts

@@ -1,3 +1,6 @@
-export const _isFormatIri = (str: string): boolean => PATTERN.test(str);
+import { _isFormatIriReference } from "./_isFormatIriReference";
 
-const PATTERN = /^[A-Za-z][\d+-.A-Za-z]*:[^\u0000-\u0020"<>\\^`{|}]*$/u;
+export const _isFormatIri = (str: string): boolean =>
+  SCHEME.test(str) && _isFormatIriReference(str);
+
+const SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*:/u;

package/src/internal/_isFormatIriReference.ts

@@ -1,4 +1,12 @@
-export const _isFormatIriReference = (str: string): boolean =>
-  PATTERN.test(str);
+export const _isFormatIriReference = (str: string): boolean => {
+  if (FORBIDDEN.test(str) || INVALID_PERCENT.test(str)) return false;
+  const colon: number = str.indexOf(":");
+  const boundary: number = str.search(/[/?#]/u);
+  return (
+    colon === -1 || (boundary !== -1 && boundary < colon) || SCHEME.test(str)
+  );
+};
 
-const PATTERN = /^[A-Za-z][\d+-.A-Za-z]*:[^\u0000-\u0020"<>\\^`{|}]*$/u;
+const FORBIDDEN = /[\u0000-\u0020\u007f-\u009f\ud800-\udfff"<>\\^`{|}]/u;
+const INVALID_PERCENT = /%(?![0-9A-Fa-f]{2})/u;
+const SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*:/u;