until

Author: sinclairzx81

example/index.ts

@@ -1,6 +1,49 @@
 // deno-fmt-ignore-file
+// deno-lint-ignore-file
 
-import { Static, Runtime, Compile } from '@sinclair/parsebox'
+import { Static, Runtime } from '@sinclair/parsebox'
+import { Type as T } from 'npm:@sinclair/typebox'
 
-// 
+const Type = Runtime.Union([
+  Runtime.Const('string'),
+  Runtime.Ref('TemplateLiteral')
+])
+const TemplateText = Runtime.Union([
+  Runtime.Until('${'),
+  Runtime.Until('`'),
+], value => T.Literal(value))
 
+const TemplateEnd = Runtime.Tuple([
+  Runtime.Ref('TemplateText'), 
+  Runtime.Const('`')
+], value => value[0])
+
+const TemplateInterpolate = Runtime.Tuple([
+  Runtime.Const('${'),
+  Runtime.Ref('Type'),
+  Runtime.Const('}')
+], value => value[1])
+
+const TemplateLiteralContent = Runtime.Union([
+  Runtime.Tuple([Runtime.Ref('TemplateText'), Runtime.Ref('TemplateInterpolate'), Runtime.Ref('TemplateLiteralContent')]),
+  Runtime.Ref('TemplateText'),
+])
+
+const TemplateLiteral = Runtime.Tuple([
+  Runtime.Const('`'),
+  Runtime.Ref('TemplateLiteralContent'),
+  Runtime.Const('`'),
+], value => value[1])
+
+const Module = new Runtime.Module({
+  TemplateLiteralContent,
+  TemplateInterpolate,
+  TemplateLiteral,
+  TemplateText,
+  TemplateEnd,
+  Type
+})
+
+const Result = Module.Parse('Type', '`hello ${string} world ${string} ${string}`')
+
+console.log(Result)

src/runtime/guard.ts

@@ -0,0 +1,45 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/parsebox
+
+The MIT License (MIT)
+
+Copyright (c) 2024-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+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
+
+export function IsEqual(left: unknown, right: unknown): boolean {
+  return left === right
+}
+export function HasPropertyKey<Key extends PropertyKey>(value: Record<PropertyKey, unknown>, key: Key): value is Record<PropertyKey, unknown> & { [_ in Key]: unknown } {
+  return key in value
+}
+export function IsObject(value: unknown): value is Record<PropertyKey, unknown> {
+  return typeof value === 'object' && value !== null
+}
+export function IsArray(value: unknown): value is unknown[] {
+  return globalThis.Array.isArray(value)
+}
+export function IsString(value: unknown): value is string {
+  return typeof value === 'string'
+}

src/runtime/parse.ts

@@ -29,6 +29,7 @@ THE SOFTWARE.
 // deno-fmt-ignore-file
 // deno-lint-ignore-file no-unused-vars no-explicit-any
 
+import { Type } from "../../example/typebox/compiled/parser.ts"
 import { Guard } from '../guard/index.ts'
 import * as Token from './token.ts'
 import * as Types from './types.ts'
@@ -67,6 +68,12 @@ function ParseConst<Value extends string>(value: Value, code: string, context: u
   return Token.Const(value, code) as never
 }
 // ------------------------------------------------------------------
+// Until
+// ------------------------------------------------------------------
+function ParseUntil<Value extends string>(value: Value, code: string, context: unknown): [] | [Value, string] {
+  return Token.Until(value, code) as never
+}
+// ------------------------------------------------------------------
 // Ident
 // ------------------------------------------------------------------
 function ParseIdent(code: string, _context: unknown): [] | [string, string] {
@@ -138,6 +145,7 @@ function ParseParser<Parser extends Types.IParser>(moduleProperties: Types.IModu
     Types.IsString(parser) ? ParseString(parser.options, code, context) :
     Types.IsTuple(parser) ? ParseTuple(moduleProperties, parser.parsers, code, context) :
     Types.IsUnion(parser) ? ParseUnion(moduleProperties, parser.parsers, code, context) :
+    Types.IsUntil(parser) ?  ParseUntil(parser.value, code, context) :
     []
   )
   return (result.length === 2 ? [parser.mapping(result[0], context), result[1]] : result) as never