Revision 0.9.7

readme.md

@@ -69,9 +69,11 @@ License: MIT
   - [Tuple](#Tuple)
   - [Union](#Union)
   - [Array](#Array)
-  - [Until](#Until)
   - [Optional](#Optional)
   - [Epsilon](#Epsilon)
+- [Range](#Range)
+  - [Until](#Until)
+  - [UntilNonEmpty](#UntilNonEmpty)
 - [Terminals](#Terminals)
   - [Number](#Number)
   - [String](#String)
@@ -187,27 +189,6 @@ const R2 = Runtime.Parse(T, 'X X X Y Z')             // const R2 = [['X', 'X', '
 const R3 = Runtime.Parse(T, 'Y Z')                   // const R3 = [[], 'Y Z']
 ```
 
-### Until
-
-The Until combinator will parse characters up to (but not including) one of the specified sentinel string values. If a sentinel value is not found, parsing fails.
-
-**BNF**
-
-```bnf
-<T> ::= ? any character until ['Z'] ?
-```
-
-**TypeScript**
-
-```typescript
-const T = Runtime.Until(['Z'])                      // const T = {
-                                                    //   type: 'Until',
-                                                    //   values: ['Z']
-                                                    // }
-
-const R = Runtime.Parse(T, 'X Y Z')                 // const R = ['X Y ', 'Z']
-```
-
 ### Optional
 
 The Optional combinator parses zero or one occurrence of the interior parser, returning a tuple with one element or an empty tuple if there is no match.
@@ -256,7 +237,58 @@ const R1 = Runtime.Parse(T, 'X Y Z')                // const R1 = [['X', 'Y'], '
 const R2 = Runtime.Parse(T, 'Y Z')                  // const R2 = [[], 'Y Z']
 ```
 
-## Terminals
+## Range Combinators
+
+ParseBox range combinators match character sequences up to one or more terminating sentinel strings. These combinators are used to match arbituary Unicode (UTF-16) sequences.
+
+
+### Until
+
+The Until combinator parses characters up to (but not including) one of the specified sentinel string values. It captures all characters encountered before the sentinel. If a sentinel value is not found in the input, parsing fails. Until succeeds even if it matches a zero-length string. This occurs if a sentinel is found immediately at the current parsing position.
+
+**BNF**
+
+```bnf
+<T> ::= ? any character sequence (0 or more) until 'Z' ?
+```
+
+**TypeScript**
+
+```typescript
+const T = Runtime.Until(['Z'])                      // const T = {
+                                                    //   type: 'Until',
+                                                    //   values: ['Z']
+                                                    // }
+
+const R = Runtime.Parse(T, 'X Y Z')                 // const R = ['X Y ', 'Z']
+```
+
+### UntilNonEmpty
+
+The UntilNonEmpty combinator works the same as Until, but it fails if the parsed content yields a zero-length string.
+
+**BNF**
+
+```bnf
+<T> ::= ? any character sequence (1 or more) until 'Z'. fails on zero length ?
+```
+
+**TypeScript**
+
+```typescript
+const T = Runtime.UntilNonEmpty(['Z'])              // const T = {
+                                                    //   type: 'UntilNonEmpty',
+                                                    //   values: ['Z']
+                                                    // }
+
+const R1 = Runtime.Parse(T, 'X Y Z')                // const R1 = ['X Y ', 'Z']
+
+const R2 = Runtime.Parse(T, ' Z')                   // const R2 = [' ', 'Z']
+
+const R3 = Runtime.Parse(T, 'Z')                    // const R3 = []
+```
+
+## Terminal Combinators
 
 ParseBox provides combinators for parsing common lexical tokens, such as numbers, identifiers, and strings, enabling static, optimized parsing of typical JavaScript constructs.
 

src/compile/common/comment.ts

@@ -27,58 +27,62 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 // deno-fmt-ignore-file
-// deno-lint-ignore-file no-unused-vars
+// deno-lint-ignore-file
 
 import { Runtime } from '../../runtime/index.ts'
 import { Unreachable } from './unreachable.ts'
 import { Escape } from './escape.ts'
 
+function FromArray(parser: Runtime.IArray): string {
+  return `${FromParser(parser.parser)}[]`
+}
 function FromContext(parser: Runtime.IContext): string {
   return `${FromParser(parser.left)} -> ${FromParser(parser.right)}`
 }
-function FromTuple(parser: Runtime.ITuple): string {
-  return `[${parser.parsers.map((parser) => `${FromParser(parser)}`).join(', ')}]`
+function FromConst(parser: Runtime.IConst): string {
+  return `'${Escape(parser.value)}'`
 }
-function FromUnion(parser: Runtime.IUnion): string {
-  return parser.parsers.map((parser) => `${FromParser(parser)}`).join(' | ')
+function FromIdent(parser: Runtime.IIdent): string {
+  return `<Ident>`
 }
-function FromArray(parser: Runtime.IArray): string {
-  return `${FromParser(parser.parser)}[]`
+function FromNumber(parser: Runtime.INumber): string {
+  return `<Number>`
 }
 function FromOptional(parser: Runtime.IOptional): string {
   return `${FromParser(parser.parser)}?`
 }
 function FromRef(parser: Runtime.IRef): string {
   return `${parser.ref}`
 }
-function FromConst(parser: Runtime.IConst): string {
-  return `'${Escape(parser.value)}'`
+function FromString(parser: Runtime.IString): string {
+  return `<String>`
 }
-function FromUntil(parser: Runtime.IUntil): string {
-  return `string`
+function FromTuple(parser: Runtime.ITuple): string {
+  return `[${parser.parsers.map((parser) => `${FromParser(parser)}`).join(', ')}]`
 }
-function FromIdent(parser: Runtime.IIdent): string {
-  return `<Ident>`
+function FromUnion(parser: Runtime.IUnion): string {
+  return parser.parsers.map((parser) => `${FromParser(parser)}`).join(' | ')
 }
-function FromString(parser: Runtime.IString): string {
-  return `<String>`
+function FromUntil(parser: Runtime.IUntil): string {
+  return `string`
 }
-function FromNumber(parser: Runtime.INumber): string {
-  return `<Number>`
+function FromUntilNonEmpty(parser: Runtime.IUntilNonEmpty): string {
+  return `string`
 }
 function FromParser(parser: Runtime.IParser): string {
   return (
-    Runtime.IsContext(parser) ? FromContext(parser) : 
-    Runtime.IsTuple(parser) ? FromTuple(parser) : 
-    Runtime.IsUnion(parser) ? FromUnion(parser) : 
     Runtime.IsArray(parser) ? FromArray(parser) : 
+    Runtime.IsContext(parser) ? FromContext(parser) : 
+    Runtime.IsConst(parser) ? FromConst(parser) : 
+    Runtime.IsIdent(parser) ? FromIdent(parser) : 
+    Runtime.IsNumber(parser) ? FromNumber(parser) :
     Runtime.IsOptional(parser) ? FromOptional(parser) : 
+    Runtime.IsRef(parser) ? FromRef(parser) : 
     Runtime.IsString(parser) ? FromString(parser) : 
-    Runtime.IsConst(parser) ? FromConst(parser) : 
+    Runtime.IsTuple(parser) ? FromTuple(parser) : 
+    Runtime.IsUnion(parser) ? FromUnion(parser) : 
     Runtime.IsUntil(parser) ? FromUntil(parser) : 
-    Runtime.IsRef(parser) ? FromRef(parser) : 
-    Runtime.IsIdent(parser) ? FromIdent(parser) : 
-    Runtime.IsNumber(parser) ? FromNumber(parser) : 
+    Runtime.IsUntilNonEmpty(parser) ? FromUntilNonEmpty(parser) : 
     Unreachable(parser)
   )
 }

src/compile/common/infer.ts

@@ -32,40 +32,58 @@ THE SOFTWARE.
 import { Runtime } from '../../runtime/index.ts'
 import { Unreachable } from './unreachable.ts'
 
-function InferUnion(parsers: Runtime.IParser[]): string {
-  return [...new Set(parsers.map((parser) => Infer(parser)))].join(' | ')
-}
-function InferTuple(parsers: Runtime.IParser[]): string {
-  return `[${parsers.map(() => 'unknown').join(', ')}]`
-}
 function InferArray(parser: Runtime.IParser): string {
   return `(${Infer(parser)})[]`
 }
 function InferContext(left: Runtime.IParser, right: Runtime.IParser) {
   return Infer(right)
 }
+function InferConst(parser: Runtime.IConst) {
+  return `'${parser.value}'`
+}
 function InferOptional(parser: Runtime.IParser) {
   return `([${Infer(parser)}] | [])`
 }
-function InferConst(parser: Runtime.IConst) {
-  return `'${parser.value}'`
+
+
+function InferUnion(parsers: Runtime.IParser[]): string {
+  return [...new Set(parsers.map((parser) => Infer(parser)))].join(' | ')
+}
+function InferString(parser: Runtime.IString) {
+  return `string`
+}
+function InferRef(parser: Runtime.IRef) {
+  return `unknown`
+}
+function InferIdent(parser: Runtime.IIdent) {
+  return `string`
+}
+function InferNumber(parser: Runtime.INumber) {
+  return `string`
+}
+function InferTuple(parsers: Runtime.IParser[]): string {
+  return `[${parsers.map(() => 'unknown').join(', ')}]`
 }
 function InferUntil(parser: Runtime.IUntil) {
   return `string`
 }
+function InferUntilNonEmpty(parser: Runtime.IUntilNonEmpty) {
+  return `string`
+}
 export function Infer(parser: Runtime.IParser): string {
   return (
+    Runtime.IsArray(parser) ? InferArray(parser.parser) :
     Runtime.IsContext(parser) ? InferContext(parser.right, parser.right) :
+    Runtime.IsConst(parser) ? InferConst(parser) :
+    Runtime.IsIdent(parser) ? InferIdent(parser) :
+    Runtime.IsNumber(parser) ? InferNumber(parser) :
+    Runtime.IsOptional(parser) ? InferOptional(parser.parser) :
+    Runtime.IsRef(parser) ? InferRef(parser) :
+    Runtime.IsString(parser) ? InferString(parser) :
     Runtime.IsTuple(parser) ? InferTuple(parser.parsers) :
     Runtime.IsUnion(parser) ? InferUnion(parser.parsers) :
-    Runtime.IsArray(parser) ? InferArray(parser.parser) :
-    Runtime.IsOptional(parser) ? InferOptional(parser.parser) :
-    Runtime.IsRef(parser) ? `unknown` :
-    Runtime.IsConst(parser) ? InferConst(parser) :
     Runtime.IsUntil(parser) ? InferUntil(parser) :
-    Runtime.IsString(parser) ? `string` :
-    Runtime.IsIdent(parser) ? `string` :
-    Runtime.IsNumber(parser) ? `string` :
+    Runtime.IsUntilNonEmpty(parser) ? InferUntilNonEmpty(parser) :
     Unreachable(parser)
   )
 }

src/compile/func/func.ts

@@ -44,20 +44,6 @@ function FromContext(options: Options, name: string, left: Runtime.IParser, righ
   return `If(${FromParser(options, name, left)}, ([_0, input]) => ${FromParser(options, name, right).replace('context', `_0 as ${options.contextType}`)}, () => [])`
 }
 // ------------------------------------------------------------------
-// Tuple
-// ------------------------------------------------------------------
-function FromTuple(options: Options, name: string, parsers: Runtime.IParser[]): string {
-  const parameters = `[${parsers.map((_, index) => `_${index}`).join(', ')}]`
-  const initial = `[${parameters}, input]`
-  return parsers.reduceRight((result, right, index) => `If(${FromParser(options, name, right)}, ([_${index}, input]) => ${result})`, initial)
-}
-// ------------------------------------------------------------------
-// Union
-// ------------------------------------------------------------------
-function FromUnion(options: Options, name: string, parsers: Runtime.IParser[]): string {
-  return parsers.length === 0 ? '[]' : parsers.reduceRight((result, right) => `If(${FromParser(options, name, right)}, ([_0, input]) => [_0, input], () => ${result})`, '[]')
-}
-// ------------------------------------------------------------------
 // Array
 // ------------------------------------------------------------------
 function FromArrayReducer(options: Options, name: string, parser: Runtime.IParser): string {
@@ -71,25 +57,12 @@ function FromArray(options: Options, name: string, parser: Runtime.IParser): str
   return `${reducer_name}(input, context)`
 }
 // ------------------------------------------------------------------
-// Optional
-// ------------------------------------------------------------------
-function FromOptional(options: Options, name: string, parser: Runtime.IOptional): string {
-  return `If(${FromParser(options, name, parser.parser)}, ([_0, input]) => [[_0], input], () => [[], input])`
-}
-// ------------------------------------------------------------------
 // Const
 // ------------------------------------------------------------------
 function FromConst(options: Options, name: string, value: string): string {
   return `Runtime.Token.Const('${Escape(value)}', input)`
 }
 // ------------------------------------------------------------------
-// Const
-// ------------------------------------------------------------------
-function FromUntil(options: Options, name: string, values: string[]): string {
-  const escaped = values.map(value => `'${Escape(value)}'`)
-  return `Runtime.Token.Until([${escaped.join(', ')}], input)`
-}
-// ------------------------------------------------------------------
 // Ident
 // ------------------------------------------------------------------
 function FromIdent(options: Options, name: string): string {
@@ -102,34 +75,69 @@ function FromNumber(options: Options, name: string): string {
   return `Runtime.Token.Number(input)`
 }
 // ------------------------------------------------------------------
+// Optional
+// ------------------------------------------------------------------
+function FromOptional(options: Options, name: string, parser: Runtime.IOptional): string {
+  return `If(${FromParser(options, name, parser.parser)}, ([_0, input]) => [[_0], input], () => [[], input])`
+}
+// ------------------------------------------------------------------
+// Ref
+// ------------------------------------------------------------------
+function FromRef(options: Options, name: string, ref: string): string {
+  return `${ref}(input, context)`
+}
+// ------------------------------------------------------------------
 // String
 // ------------------------------------------------------------------
 function FromString(options: Options, name: string, string_options: string[]): string {
   const _options = string_options.map((option) => `'${Escape(option)}'`).join(', ')
   return `Runtime.Token.String([${_options}], input)`
 }
 // ------------------------------------------------------------------
-// Ref
+// Tuple
 // ------------------------------------------------------------------
-function FromRef(options: Options, name: string, ref: string): string {
-  return `${ref}(input, context)`
+function FromTuple(options: Options, name: string, parsers: Runtime.IParser[]): string {
+  const parameters = `[${parsers.map((_, index) => `_${index}`).join(', ')}]`
+  const initial = `[${parameters}, input]`
+  return parsers.reduceRight((result, right, index) => `If(${FromParser(options, name, right)}, ([_${index}, input]) => ${result})`, initial)
 }
 // ------------------------------------------------------------------
-// Ref
+// Union
+// ------------------------------------------------------------------
+function FromUnion(options: Options, name: string, parsers: Runtime.IParser[]): string {
+  return parsers.length === 0 ? '[]' : parsers.reduceRight((result, right) => `If(${FromParser(options, name, right)}, ([_0, input]) => [_0, input], () => ${result})`, '[]')
+}
+// ------------------------------------------------------------------
+// Until
+// ------------------------------------------------------------------
+function FromUntil(options: Options, name: string, values: string[]): string {
+  const escaped = values.map(value => `'${Escape(value)}'`)
+  return `Runtime.Token.Until([${escaped.join(', ')}], input)`
+}
+// ------------------------------------------------------------------
+// UntilNonEmpty
+// ------------------------------------------------------------------
+function FromUntilNonEmpty(options: Options, name: string, values: string[]): string {
+  const escaped = values.map(value => `'${Escape(value)}'`)
+  return `Runtime.Token.UntilNonEmpty([${escaped.join(', ')}], input)`
+}
+// ------------------------------------------------------------------
+// Parser
 // ------------------------------------------------------------------
 function FromParser(options: Options, name: string, parser: Runtime.IParser): string {
   return (
-    Runtime.IsContext(parser) ? FromContext(options, name, parser.left, parser.right) :
-    Runtime.IsTuple(parser) ? FromTuple(options, name, parser.parsers) :
-    Runtime.IsUnion(parser) ? FromUnion(options, name, parser.parsers) :
     Runtime.IsArray(parser) ? FromArray(options, name, parser.parser) :
-    Runtime.IsOptional(parser) ? FromOptional(options, name, parser) :
-    Runtime.IsString(parser) ? FromString(options, name, parser.options) :
+    Runtime.IsContext(parser) ? FromContext(options, name, parser.left, parser.right) :
     Runtime.IsConst(parser) ? FromConst(options, name, parser.value) :
-    Runtime.IsUntil(parser) ? FromUntil(options, name, parser.values) :
-    Runtime.IsRef(parser) ? FromRef(options, name, parser.ref) :
     Runtime.IsIdent(parser) ? FromIdent(options, name) :
     Runtime.IsNumber(parser) ? FromNumber(options, name) :
+    Runtime.IsOptional(parser) ? FromOptional(options, name, parser) :
+    Runtime.IsRef(parser) ? FromRef(options, name, parser.ref) :
+    Runtime.IsString(parser) ? FromString(options, name, parser.options) :
+    Runtime.IsTuple(parser) ? FromTuple(options, name, parser.parsers) :
+    Runtime.IsUnion(parser) ? FromUnion(options, name, parser.parsers) :
+    Runtime.IsUntil(parser) ? FromUntil(options, name, parser.values) :
+    Runtime.IsUntilNonEmpty(parser) ? FromUntilNonEmpty(options, name, parser.values) :
     Unreachable(parser)
   )
 }