Revision 0.11.3

Author: sinclairzx81

src/build/common/comment.ts

@@ -68,6 +68,12 @@ function FromTuple(parser: Runtime.ITuple): string {
 function FromUnion(parser: Runtime.IUnion): string {
   return parser.parsers.map((parser) => `${FromParser(parser)}`).join(' | ')
 }
+function FromUnsignedInteger(parser: Runtime.IUnsignedInteger): string {
+  return `<UnsignedInteger>`
+}
+function FromUnsignedNumber(parser: Runtime.IUnsignedNumber): string {
+  return `<UnsignedNumber>`
+}
 function FromUntil_1(parser: Runtime.IUntil_1): string {
   return `string`
 }
@@ -79,15 +85,17 @@ function FromParser(parser: Runtime.IParser): string {
     Runtime.IsArray(parser) ? FromArray(parser) :
     Runtime.IsBigInt(parser) ? FromBigInt(parser) :
     Runtime.IsConst(parser) ? FromConst(parser) :
-    Runtime.IsInteger(parser) ? FromInteger(parser) :
     Runtime.IsIdent(parser) ? FromIdent(parser) :
+    Runtime.IsInteger(parser) ? FromInteger(parser) :
     Runtime.IsNumber(parser) ? FromNumber(parser) :
     Runtime.IsOptional(parser) ? FromOptional(parser) :
     Runtime.IsRef(parser) ? FromRef(parser) :
     Runtime.IsRest(parser) ? FromRest(parser) :
     Runtime.IsString(parser) ? FromString(parser) :
     Runtime.IsTuple(parser) ? FromTuple(parser) :
     Runtime.IsUnion(parser) ? FromUnion(parser) :
+    Runtime.IsUnsignedInteger(parser) ? FromUnsignedInteger(parser) :
+    Runtime.IsUnsignedNumber(parser) ? FromUnsignedNumber(parser) :
     Runtime.IsUntil_1(parser) ? FromUntil_1(parser) :
     Runtime.IsUntil(parser) ? FromUntil(parser) :
     Unreachable(parser)

src/build/common/infer.ts

@@ -47,12 +47,12 @@ function InferIdent(parser: Runtime.IIdent) {
 function InferInteger(parser: Runtime.IInteger) {
   return `string`
 }
+function InferNumber(parser: Runtime.INumber) {
+  return `string`
+}
 function InferOptional(parser: Runtime.IParser) {
   return `([${Infer(parser)}] | [])`
 }
-function InferUnion(parsers: Runtime.IParser[]): string {
-  return [...new Set(parsers.map((parser) => Infer(parser)))].join(' | ')
-}
 function InferString(parser: Runtime.IString) {
   return `string`
 }
@@ -62,12 +62,18 @@ function InferRef(parser: Runtime.IRef) {
 function InferRest(parser: Runtime.IRest) {
   return `string`
 }
-function InferNumber(parser: Runtime.INumber) {
-  return `string`
-}
 function InferTuple(parsers: Runtime.IParser[]): string {
   return `[${parsers.map(() => 'unknown').join(', ')}]`
 }
+function InferUnion(parsers: Runtime.IParser[]): string {
+  return [...new Set(parsers.map((parser) => Infer(parser)))].join(' | ')
+}
+function InferUnsignedInteger(parser: Runtime.IUnsignedInteger) {
+  return `number`
+}
+function InferUnsignedNumber(parser: Runtime.IUnsignedNumber) {
+  return `number`
+}
 function InferUntil_1(parser: Runtime.IUntil_1) {
   return `string`
 }
@@ -79,15 +85,17 @@ export function Infer(parser: Runtime.IParser): string {
     Runtime.IsArray(parser) ? InferArray(parser.parser) :
     Runtime.IsBigInt(parser) ? InferBigInt(parser) :
     Runtime.IsConst(parser) ? InferConst(parser) :
-    Runtime.IsInteger(parser) ? InferInteger(parser) :
     Runtime.IsIdent(parser) ? InferIdent(parser) :
+    Runtime.IsInteger(parser) ? InferInteger(parser) :
     Runtime.IsNumber(parser) ? InferNumber(parser) :
     Runtime.IsOptional(parser) ? InferOptional(parser.parser) :
     Runtime.IsRef(parser) ? InferRef(parser) :
     Runtime.IsRest(parser) ? InferRest(parser) :
     Runtime.IsString(parser) ? InferString(parser) :
     Runtime.IsTuple(parser) ? InferTuple(parser.parsers) :
     Runtime.IsUnion(parser) ? InferUnion(parser.parsers) :
+    Runtime.IsUnsignedInteger(parser) ? InferUnsignedInteger(parser) :
+    Runtime.IsUnsignedNumber(parser) ? InferUnsignedNumber(parser) :
     Runtime.IsUntil_1(parser) ? InferUntil_1(parser) :
     Runtime.IsUntil(parser) ? InferUntil(parser) :
     Unreachable(parser)

src/build/runtime/parse.ts

@@ -122,6 +122,18 @@ function FromUnion(name: string, parsers: Runtime.IParser[]): string {
   return parsers.length === 0 ? '[]' : parsers.reduceRight((result, right) => `If(${FromParser(name, right)}, ([_0, input]) => [_0, input], () => ${result})`, '[]')
 }
 // ------------------------------------------------------------------
+// UnsignedInteger
+// ------------------------------------------------------------------
+function FromUnsignedInteger(name: string): string {
+  return `Token.UnsignedInteger(input)`
+}
+// ------------------------------------------------------------------
+// UnsignedNumber
+// ------------------------------------------------------------------
+function FromUnsignedNumber(name: string): string {
+  return `Token.UnsignedNumber(input)`
+}
+// ------------------------------------------------------------------
 // Until_1
 // ------------------------------------------------------------------
 function FromUntil_1(name: string, end: string[]): string {
@@ -152,6 +164,8 @@ function FromParser(name: string, parser: Runtime.IParser): string {
     Runtime.IsString(parser) ? FromString(name, parser.quotes) :
     Runtime.IsTuple(parser) ? FromTuple(name, parser.parsers) :
     Runtime.IsUnion(parser) ? FromUnion(name, parser.parsers) :
+    Runtime.IsUnsignedInteger(parser) ? FromUnsignedInteger(name) :
+    Runtime.IsUnsignedNumber(parser) ? FromUnsignedNumber(name) :
     Runtime.IsUntil_1(parser) ? FromUntil_1(name, parser.end) :
     Runtime.IsUntil(parser) ? FromUntil(name, parser.end) :
     Unreachable(parser)

src/build/static/parse.ts

@@ -121,6 +121,18 @@ function FromUnion(name: string, parsers: Runtime.IParser[]): string {
   return parsers.length === 0 ? '[]' : `(${parsers.reduceRight((result, right) => `${FromParser(name, right)} extends [infer _0, infer Input extends string] ? [_0, Input] : ${result}`, '[]')})`
 }
 // ------------------------------------------------------------------
+// UnsignedInteger
+// ------------------------------------------------------------------
+function FromUnsignedInteger(name: string): string {
+  return `Token.TUnsignedInteger<Input>`
+}
+// ------------------------------------------------------------------
+// UnsignedNumber
+// ------------------------------------------------------------------
+function FromUnsignedNumber(name: string): string {
+  return `Token.TUnsignedNumber<Input>`
+}
+// ------------------------------------------------------------------
 // Until_1
 // ------------------------------------------------------------------
 function FromUntil_1(name: string, end: string[]): string {
@@ -142,15 +154,17 @@ function FromParser(name: string, parser: Runtime.IParser): string {
     Runtime.IsArray(parser) ? FromArray(name, parser.parser) :
     Runtime.IsBigInt(parser) ? FromBigInt(name) :
     Runtime.IsConst(parser) ? FromConst(name, parser.const) :
-    Runtime.IsInteger(parser) ? FromInteger(name) :
     Runtime.IsIdent(parser) ? FromIdent(name) :
+    Runtime.IsInteger(parser) ? FromInteger(name) :
     Runtime.IsNumber(parser) ? FromNumber(name) :
     Runtime.IsOptional(parser) ? FromOptional(name, parser) :
     Runtime.IsRef(parser) ? FromRef(name, parser.ref) :
     Runtime.IsRest(parser) ? FromRest(name) :
     Runtime.IsString(parser) ? FromString(name, parser.quotes) :
     Runtime.IsTuple(parser) ? FromTuple(name, parser.parsers) :
     Runtime.IsUnion(parser) ? FromUnion(name, parser.parsers) :
+    Runtime.IsUnsignedInteger(parser) ? FromUnsignedInteger(name) :
+    Runtime.IsUnsignedNumber(parser) ? FromUnsignedNumber(name) :
     Runtime.IsUntil_1(parser) ? FromUntil_1(name, parser.end) :
     Runtime.IsUntil(parser) ? FromUntil(name, parser.end) :
     Unreachable(parser)

src/runtime/index.ts

@@ -43,5 +43,7 @@ export { type IRest, Rest, IsRest, } from './rest.ts'
 export { type IString, IsString, String } from './string.ts'
 export { type ITuple, IsTuple, Tuple } from './tuple.ts'
 export { type IUnion, IsUnion, Union } from './union.ts'
+export { type IUnsignedInteger, IsUnsignedInteger, UnsignedInteger } from './unsigned_integer.ts'
+export { type IUnsignedNumber, IsUnsignedNumber, UnsignedNumber } from './unsigned_number.ts'
 export { type IUntil_1, IsUntil_1, Until_1 } from './until_1.ts'
 export { type IUntil, IsUntil, Until } from './until.ts'

src/runtime/parse.ts

@@ -46,6 +46,8 @@ import { ParseRest, IsRest } from './rest.ts'
 import { ParseString, IsString } from './string.ts'
 import { ParseTuple, IsTuple } from './tuple.ts'
 import { ParseUnion, IsUnion } from './union.ts'
+import { ParseUnsignedInteger, IsUnsignedInteger } from './unsigned_integer.ts'
+import { ParseUnsignedNumber, IsUnsignedNumber} from './unsigned_number.ts'
 import { ParseUntil_1, IsUntil_1 } from './until_1.ts'
 import { ParseUntil, IsUntil } from './until.ts'
 
@@ -66,6 +68,8 @@ export function ParseParser<Parser extends IParser>(context: IProperties, parser
     IsString(parser) ? ParseString(parser.quotes, input) :
     IsTuple(parser) ? ParseTuple(context, parser.parsers, input) :
     IsUnion(parser) ? ParseUnion(context, parser.parsers, input) :
+    IsUnsignedInteger(parser) ? ParseUnsignedInteger(input) :
+    IsUnsignedNumber(parser) ? ParseUnsignedNumber(input) :
     IsUntil(parser) ? ParseUntil(parser.end, input) :
     IsUntil_1(parser) ? ParseUntil_1(parser.end, input) :
     []

src/runtime/unsigned_integer.ts

@@ -0,0 +1,68 @@
+/*--------------------------------------------------------------------------
+
+ParseBox
+
+The MIT License (MIT)
+
+Copyright (c) 2024-2026 Haydn Paterson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+// deno-fmt-ignore-file
+
+import * as Token from '../token/index.ts'
+
+import { Arguments } from '../system/arguments/index.ts'
+import { Guard } from '../guard/index.ts'
+import { type IParser, type IMapping, Identity } from './parser.ts'
+
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+export interface IUnsignedInteger<Output extends unknown = unknown> extends IParser<Output> {
+  type: 'UnsignedInteger'
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+export function UnsignedInteger<Mapping extends IMapping<string>>(mapping: Mapping): IUnsignedInteger<ReturnType<Mapping>>
+export function UnsignedInteger(): IUnsignedInteger<string>
+export function UnsignedInteger(...args: unknown[]): never {
+  const [mapping] = Arguments.Match<[IParser, IMapping]>(args, {
+    1: (mapping) => [mapping],
+    0: () => [Identity]
+  })
+  return { type: 'UnsignedInteger', mapping } as never
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+export function IsUnsignedInteger(value: unknown): value is IUnsignedInteger {
+  return Guard.IsObject(value)
+    && Guard.HasPropertyKey(value, 'type')
+    && Guard.IsEqual(value.type, 'UnsignedInteger')
+}
+// ------------------------------------------------------------------
+// Parse
+// ------------------------------------------------------------------
+export function ParseUnsignedInteger(input: string): [] | [string, string] {
+  return Token.UnsignedInteger(input)
+}

src/runtime/unsigned_number.ts

@@ -0,0 +1,68 @@
+/*--------------------------------------------------------------------------
+
+ParseBox
+
+The MIT License (MIT)
+
+Copyright (c) 2024-2026 Haydn Paterson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+// deno-fmt-ignore-file
+
+import * as Token from '../token/index.ts'
+
+import { Arguments } from '../system/arguments/index.ts'
+import { Guard } from '../guard/index.ts'
+import { type IParser, type IMapping, Identity } from './parser.ts'
+
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+export interface IUnsignedNumber<Output extends unknown = unknown> extends IParser<Output> {
+  type: 'UnsignedNumber'
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+export function UnsignedNumber<Mapping extends IMapping<string>>(mapping: Mapping): IUnsignedNumber<ReturnType<Mapping>>
+export function UnsignedNumber(): IUnsignedNumber<string>
+export function UnsignedNumber(...args: unknown[]): never {
+  const [mapping] = Arguments.Match<[IParser, IMapping]>(args, {
+    1: (mapping) => [mapping],
+    0: () => [Identity]
+  })
+  return { type: 'UnsignedNumber', mapping } as never
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+export function IsUnsignedNumber(value: unknown): value is IUnsignedNumber {
+  return Guard.IsObject(value)
+    && Guard.HasPropertyKey(value, 'type')
+    && Guard.IsEqual(value.type, 'UnsignedNumber')
+}
+// ------------------------------------------------------------------
+// Parse
+// ------------------------------------------------------------------
+export function ParseUnsignedNumber(input: string): [] | [string, string] {
+  return Token.UnsignedNumber(input)
+}

src/static/index.ts

@@ -39,5 +39,7 @@ export type { Rest } from './rest.ts'
 export type { String } from './string.ts'
 export type { Tuple } from './tuple.ts'
 export type { Union } from './union.ts'
+export type { UnsignedInteger } from './unsigned_integer.ts'
+export type { UnsignedNumber } from './unsigned_number.ts'
 export type { Until_1 } from './until_1.ts'
 export type { Until } from './until.ts'

src/static/parse.ts

@@ -39,6 +39,8 @@ import type { ParseRest, Rest } from './rest.ts'
 import type { ParseString, String } from './string.ts'
 import type { ParseTuple, Tuple } from './tuple.ts'
 import type { ParseUnion, Union } from './union.ts'
+import type { ParseUnsignedInteger, UnsignedInteger } from './unsigned_integer.ts'
+import type { ParseUnsignedNumber, UnsignedNumber } from './unsigned_number.ts'
 import type { ParseUntil_1, Until_1 } from './until_1.ts'
 import type { ParseUntil, Until } from './until.ts'
 
@@ -58,10 +60,12 @@ type ParseInput<Input extends string, Parser extends IParser> = (
   Parser extends Rest ? ParseRest<Input> : 
   Parser extends String<infer Quotes extends string[]> ? ParseString<Quotes, Input> : 
   Parser extends Tuple<infer Parsers extends IParser[]> ? ParseTuple<Parsers, Input> : 
-  Parser extends Union<infer Parsers extends IParser[]> ? ParseUnion<Parsers, Input> : 
+  Parser extends Union<infer Parsers extends IParser[]> ? ParseUnion<Parsers, Input> :
+  Parser extends UnsignedInteger ? ParseUnsignedInteger<Input> :
+  Parser extends UnsignedNumber ? ParseUnsignedNumber<Input> :  
   Parser extends Until<infer End extends string[]> ? ParseUntil<End, Input> : 
-  Parser extends Until_1<infer End extends string[]> ? ParseUntil_1<End, Input>
-  : []
+  Parser extends Until_1<infer End extends string[]> ? ParseUntil_1<End, Input> : 
+  []
 )
 // ------------------------------------------------------------------
 // ParseMapping