Unsigned | Match

Author: sinclairzx81

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

src/static/unsigned_integer.ts

@@ -0,0 +1,45 @@
+/*--------------------------------------------------------------------------
+
+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 type { Identity, IMapping, IParser } from './parser.ts'
+import * as Token from '../token/index.ts'
+
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+export interface UnsignedInteger<Mapping extends IMapping = Identity> extends IParser<Mapping> {
+  type: 'UnsignedInteger'
+}
+// ------------------------------------------------------------------
+// Parse
+// ------------------------------------------------------------------
+export type ParseUnsignedInteger<Input extends string> = (
+  Token.TUnsignedInteger<Input>
+)

src/static/unsigned_number.ts

@@ -0,0 +1,45 @@
+/*--------------------------------------------------------------------------
+
+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 type { Identity, IMapping, IParser } from './parser.ts'
+import * as Token from '../token/index.ts'
+
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+export interface UnsignedNumber<Mapping extends IMapping = Identity> extends IParser<Mapping> {
+  type: 'UnsignedNumber'
+}
+// ------------------------------------------------------------------
+// Parse
+// ------------------------------------------------------------------
+export type ParseUnsignedNumber<Input extends string> = (
+  Token.TUnsignedNumber<Input>
+)

src/token/bigint.ts

@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
-import { IsResult } from './internal/result.ts'
+import { Match } from './internal/match.ts'
 import { type TTake, Take } from './internal/take.ts'
 import { type TInteger, Integer } from './integer.ts'
 
@@ -37,21 +37,17 @@ import { type TInteger, Integer } from './integer.ts'
 // ------------------------------------------------------------------
 type TTakeBigInt<Input extends string> = (
   TInteger<Input> extends [infer Integer extends string, infer IntegerRest extends string]
-    ? TTake<['n'], IntegerRest> extends [infer N extends string, infer NRest extends string]
+    ? TTake<['n'], IntegerRest> extends [infer _N extends string, infer NRest extends string]
       ? [`${Integer}`, NRest]
       : [] // fail: did not match 'n'
     : [] // fail: did not match Integer
 )
 function TakeBigInt<Input extends string>(input: Input): TTakeBigInt<Input> {
-  const integer = Integer(input)
-  return (
-    IsResult(integer) ? (() => {
-      const n = Take(['n'], integer[1])
-      return IsResult(n)
-        ? [`${integer[0]}`, n[1]]
-        : [] // fail: did not match 'n'
-    })() : [] // fail: did not match Integer
-  ) as never
+  return Match(Integer(input), (Integer, IntegerRest) => 
+    Match(Take(['n'], IntegerRest), (_N, NRest) => 
+      [`${Integer}`, NRest], 
+      () => []), // fail: did not match 'n'
+    () => []) as never // fail: did not match Integer
 }
 // ------------------------------------------------------------------
 // BigInt

src/token/ident.ts

@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
-import { IsResult } from './internal/result.ts'
+import { Match } from './internal/match.ts'
 import { type TTrim, Trim } from './internal/trim.ts'
 import { type TTake, Take } from './internal/take.ts'
 
@@ -61,12 +61,9 @@ type TTakeRemaining<Input extends string, Result extends string = ''> = (
     : [Result, Input]
 )
 function TakeRemaining<Input extends string>(input: Input, result: string = ''): TTakeRemaining<Input> {
-  const remaining = Take(Remaining, input) as string[]
-  return (
-    IsResult(remaining)
-      ? TakeRemaining(remaining[1], `${result}${remaining[0]}`)
-      : [result, input]
-  ) as never
+  return Match(Take(Remaining, input), (Remaining, RemainingRest) => 
+    TakeRemaining(RemainingRest, `${result}${Remaining}`),
+    () => [result, input]) as never
 }
 // ------------------------------------------------------------------
 // TakeIdent
@@ -79,15 +76,11 @@ type TTakeIdent<Input extends string> = (
     : [] // fail: did not match Initial
 )
 function TakeIdent<Input extends string>(input: Input): TTakeIdent<Input> {
-  const initial = TakeInitial(input) as string[]
-  return (
-    IsResult(initial) ? (() => {
-      const remaining = TakeRemaining(initial[1])
-      return IsResult(remaining)
-        ? [`${initial[0]}${remaining[0]}`, remaining[1]]
-        : [] // fail: did not match Remaining
-    })() : [] // fail: did not match Initial
-  ) as never
+  return Match(TakeInitial(input), (Initial, InitialRest) => 
+    Match(TakeRemaining(InitialRest), (Remaining, RemainingRest) => 
+      [`${Initial}${Remaining}`, RemainingRest], 
+      () => []), // fail: did not match Remaining
+    () => []) as never // fail: did not match Initial
 }
 // ------------------------------------------------------------------
 // Ident

src/token/index.ts

@@ -34,5 +34,7 @@ export * from './number.ts'
 export * from './rest.ts'
 export * from './span.ts'
 export * from './string.ts'
+export * from './unsigned_integer.ts'
+export * from './unsigned_number.ts'
 export * from './until_1.ts'
 export * from './until.ts'