@bcts/envelope-pattern 1.0.0-alpha.15 → 1.0.0-alpha.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bcts/envelope-pattern",
-  "version": "1.0.0-alpha.15",
+  "version": "1.0.0-alpha.17",
   "type": "module",
   "description": "Pattern matching for Gordian Envelope structures",
   "license": "BSD-2-Clause-Patent",
@@ -60,16 +60,16 @@
     "@bcts/eslint": "^0.1.0",
     "@bcts/tsconfig": "^0.1.0",
     "eslint": "^9.39.2",
-    "tsdown": "^0.18.4",
-    "typedoc": "^0.28.15",
+    "tsdown": "^0.20.1",
+    "typedoc": "^0.28.16",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
+    "vitest": "^4.0.18"
   },
   "dependencies": {
-    "@bcts/dcbor": "^1.0.0-alpha.15",
-    "@bcts/dcbor-parse": "^1.0.0-alpha.15",
-    "@bcts/dcbor-pattern": "^1.0.0-alpha.15",
-    "@bcts/envelope": "^1.0.0-alpha.15",
-    "@bcts/known-values": "^1.0.0-alpha.15"
+    "@bcts/dcbor": "^1.0.0-alpha.17",
+    "@bcts/dcbor-parse": "^1.0.0-alpha.17",
+    "@bcts/dcbor-pattern": "^1.0.0-alpha.17",
+    "@bcts/envelope": "^1.0.0-alpha.17",
+    "@bcts/known-values": "^1.0.0-alpha.17"
   }
 }

package/src/format.ts

@@ -97,15 +97,15 @@ export function defaultFormatPathsOpts(): FormatPathsOpts {
  * Builder for FormatPathsOpts.
  */
 export class FormatPathsOptsBuilder {
-  #indent = true;
-  #elementFormat: PathElementFormat = defaultPathElementFormat();
-  #lastElementOnly = false;
+  private _indent = true;
+  private _elementFormat: PathElementFormat = defaultPathElementFormat();
+  private _lastElementOnly = false;
 
   /**
    * Sets whether to indent each path element.
    */
   indent(indent: boolean): this {
-    this.#indent = indent;
+    this._indent = indent;
     return this;
   }
 
@@ -113,7 +113,7 @@ export class FormatPathsOptsBuilder {
    * Sets the format for each path element.
    */
   elementFormat(format: PathElementFormat): this {
-    this.#elementFormat = format;
+    this._elementFormat = format;
     return this;
   }
 
@@ -121,7 +121,7 @@ export class FormatPathsOptsBuilder {
    * Sets whether to format only the last element of each path.
    */
   lastElementOnly(lastElementOnly: boolean): this {
-    this.#lastElementOnly = lastElementOnly;
+    this._lastElementOnly = lastElementOnly;
     return this;
   }
 
@@ -130,9 +130,9 @@ export class FormatPathsOptsBuilder {
    */
   build(): FormatPathsOpts {
     return {
-      indent: this.#indent,
-      elementFormat: this.#elementFormat,
-      lastElementOnly: this.#lastElementOnly,
+      indent: this._indent,
+      elementFormat: this._elementFormat,
+      lastElementOnly: this._lastElementOnly,
     };
   }
 }

package/src/parse/token.ts

@@ -183,31 +183,31 @@ function isHexDigit(ch: string): boolean {
  * Lexer for Gordian Envelope pattern syntax.
  */
 export class Lexer {
-  readonly #source: string;
-  #position = 0;
-  #tokenStart = 0;
-  #peekedToken: { token: Token; span: Span } | undefined = undefined;
+  private readonly _source: string;
+  private _position = 0;
+  private _tokenStart = 0;
+  private _peekedToken: { token: Token; span: Span } | undefined = undefined;
 
   constructor(source: string) {
-    this.#source = source;
+    this._source = source;
   }
 
   /**
    * Gets the current position in the source.
    */
   get position(): number {
-    return this.#position;
+    return this._position;
   }
 
   /**
    * Peeks at the next token without consuming it.
    */
   peekToken(): { token: Token; span: Span } | undefined {
-    if (this.#peekedToken !== undefined) {
-      return this.#peekedToken;
+    if (this._peekedToken !== undefined) {
+      return this._peekedToken;
     }
     const result = this.next();
-    this.#peekedToken = result;
+    this._peekedToken = result;
     return result;
   }
 
@@ -215,51 +215,51 @@ export class Lexer {
    * Gets the current span (from token start to current position).
    */
   span(): Span {
-    return { start: this.#tokenStart, end: this.#position };
+    return { start: this._tokenStart, end: this._position };
   }
 
   /**
    * Gets the remaining source string.
    */
   remainder(): string {
-    return this.#source.slice(this.#position);
+    return this._source.slice(this._position);
   }
 
   /**
    * Peeks at the current character without consuming it.
    */
   peek(): string | undefined {
-    if (this.#position >= this.#source.length) {
+    if (this._position >= this._source.length) {
       return undefined;
     }
-    return this.#source[this.#position];
+    return this._source[this._position];
   }
 
   /**
    * Peeks at the next character without consuming current.
    */
   peekNext(): string | undefined {
-    if (this.#position + 1 >= this.#source.length) {
+    if (this._position + 1 >= this._source.length) {
       return undefined;
     }
-    return this.#source[this.#position + 1];
+    return this._source[this._position + 1];
   }
 
   /**
    * Advances the position by n characters.
    */
   bump(n = 1): void {
-    this.#position = Math.min(this.#position + n, this.#source.length);
+    this._position = Math.min(this._position + n, this._source.length);
   }
 
   /**
    * Skips whitespace.
    */
-  #skipWhitespace(): void {
-    while (this.#position < this.#source.length) {
-      const ch = this.#source[this.#position];
+  private _skipWhitespace(): void {
+    while (this._position < this._source.length) {
+      const ch = this._source[this._position];
       if (ch !== undefined && isWhitespace(ch)) {
-        this.#position++;
+        this._position++;
       } else {
         break;
       }
@@ -269,7 +269,7 @@ export class Lexer {
   /**
    * Parses a string literal (after the opening quote).
    */
-  #parseStringLiteral(): Result<string> {
+  private _parseStringLiteral(): Result<string> {
     const src = this.remainder();
     let escape = false;
     let content = "";
@@ -323,7 +323,7 @@ export class Lexer {
   /**
    * Parses a regex pattern (after the opening slash).
    */
-  #parseRegex(): Result<string> {
+  private _parseRegex(): Result<string> {
     const src = this.remainder();
     let escape = false;
 
@@ -358,7 +358,7 @@ export class Lexer {
   /**
    * Parses a hex pattern (after h').
    */
-  #parseHexPattern(): Result<Uint8Array> {
+  private _parseHexPattern(): Result<Uint8Array> {
     const src = this.remainder();
 
     for (let i = 0; i < src.length; i++) {
@@ -397,7 +397,7 @@ export class Lexer {
   /**
    * Parses a hex binary regex (after h'/).
    */
-  #parseHexBinaryRegex(): Result<string> {
+  private _parseHexBinaryRegex(): Result<string> {
     const src = this.remainder();
     let escape = false;
 
@@ -436,7 +436,7 @@ export class Lexer {
   /**
    * Parses a date pattern (after date').
    */
-  #parseDatePattern(): Result<string> {
+  private _parseDatePattern(): Result<string> {
     const src = this.remainder();
 
     for (let i = 0; i < src.length; i++) {
@@ -455,7 +455,7 @@ export class Lexer {
   /**
    * Parses a range pattern (after {).
    */
-  #parseRange(): Result<Quantifier> {
+  private _parseRange(): Result<Quantifier> {
     const src = this.remainder();
     let pos = 0;
 
@@ -554,7 +554,7 @@ export class Lexer {
   /**
    * Parses a single quoted pattern (after ').
    */
-  #parseSingleQuotedPattern(): Result<string> {
+  private _parseSingleQuotedPattern(): Result<string> {
     const src = this.remainder();
 
     for (let i = 0; i < src.length; i++) {
@@ -573,7 +573,7 @@ export class Lexer {
   /**
    * Parses a single quoted regex (after '/).
    */
-  #parseSingleQuotedRegex(): Result<string> {
+  private _parseSingleQuotedRegex(): Result<string> {
     const src = this.remainder();
     let escape = false;
 
@@ -612,8 +612,8 @@ export class Lexer {
   /**
    * Parses a number (integer or float).
    */
-  #parseNumber(): Token {
-    const startPos = this.#position;
+  private _parseNumber(): Token {
+    const startPos = this._position;
     let isFloat = false;
     let isNegative = false;
 
@@ -662,7 +662,7 @@ export class Lexer {
       }
     }
 
-    const numStr = this.#source.slice(startPos, this.#position);
+    const numStr = this._source.slice(startPos, this._position);
 
     if (isFloat) {
       const value = parseFloat(numStr);
@@ -688,25 +688,25 @@ export class Lexer {
    */
   next(): { token: Token; span: Span } | undefined {
     // Return peeked token if available
-    if (this.#peekedToken !== undefined) {
-      const peeked = this.#peekedToken;
-      this.#peekedToken = undefined;
+    if (this._peekedToken !== undefined) {
+      const peeked = this._peekedToken;
+      this._peekedToken = undefined;
       return peeked;
     }
 
-    this.#skipWhitespace();
-    this.#tokenStart = this.#position;
+    this._skipWhitespace();
+    this._tokenStart = this._position;
 
-    if (this.#position >= this.#source.length) {
+    if (this._position >= this._source.length) {
       return undefined;
     }
 
-    const ch = this.#source[this.#position];
+    const ch = this._source[this._position];
     if (ch === undefined) return undefined;
 
     // Check for two-character operators first
-    const twoChar = this.#source.slice(this.#position, this.#position + 2);
-    const threeChar = this.#source.slice(this.#position, this.#position + 3);
+    const twoChar = this._source.slice(this._position, this._position + 2);
+    const threeChar = this._source.slice(this._position, this._position + 3);
 
     // Check for ... (ellipsis)
     if (threeChar === "...") {
@@ -715,7 +715,7 @@ export class Lexer {
     }
 
     // Check for -Infinity
-    if (this.#source.slice(this.#position, this.#position + 9) === "-Infinity") {
+    if (this._source.slice(this._position, this._position + 9) === "-Infinity") {
       this.bump(9);
       return { token: { type: "NegativeInfinity" }, span: this.span() };
     }
@@ -755,16 +755,16 @@ export class Lexer {
         if (this.peek() === "/") {
           this.bump(1);
           return {
-            token: { type: "HexBinaryRegex", value: this.#parseHexBinaryRegex() },
+            token: { type: "HexBinaryRegex", value: this._parseHexBinaryRegex() },
             span: this.span(),
           };
         }
-        return { token: { type: "HexPattern", value: this.#parseHexPattern() }, span: this.span() };
+        return { token: { type: "HexPattern", value: this._parseHexPattern() }, span: this.span() };
       }
       case "'/":
         this.bump(2);
         return {
-          token: { type: "SingleQuotedRegex", value: this.#parseSingleQuotedRegex() },
+          token: { type: "SingleQuotedRegex", value: this._parseSingleQuotedRegex() },
           span: this.span(),
         };
     }
@@ -813,25 +813,25 @@ export class Lexer {
       case '"':
         this.bump(1);
         return {
-          token: { type: "StringLiteral", value: this.#parseStringLiteral() },
+          token: { type: "StringLiteral", value: this._parseStringLiteral() },
           span: this.span(),
         };
       case "/":
         this.bump(1);
-        return { token: { type: "Regex", value: this.#parseRegex() }, span: this.span() };
+        return { token: { type: "Regex", value: this._parseRegex() }, span: this.span() };
       case "{":
         this.bump(1);
-        return { token: { type: "Range", value: this.#parseRange() }, span: this.span() };
+        return { token: { type: "Range", value: this._parseRange() }, span: this.span() };
       case "'":
         this.bump(1);
         return {
-          token: { type: "SingleQuotedPattern", value: this.#parseSingleQuotedPattern() },
+          token: { type: "SingleQuotedPattern", value: this._parseSingleQuotedPattern() },
           span: this.span(),
         };
       case "@": {
         // Group name
         this.bump(1);
-        const start = this.#position;
+        const start = this._position;
         let gc = this.peek();
         if (gc !== undefined && isIdentStart(gc)) {
           gc = this.peek();
@@ -839,7 +839,7 @@ export class Lexer {
             this.bump(1);
             gc = this.peek();
           }
-          const name = this.#source.slice(start, this.#position);
+          const name = this._source.slice(start, this._position);
           return { token: { type: "GroupName", name }, span: this.span() };
         }
         // Invalid group name, return as error token
@@ -848,26 +848,26 @@ export class Lexer {
     }
 
     // Check for date' pattern
-    if (this.#source.slice(this.#position, this.#position + 5) === "date'") {
+    if (this._source.slice(this._position, this._position + 5) === "date'") {
       this.bump(5);
-      return { token: { type: "DatePattern", value: this.#parseDatePattern() }, span: this.span() };
+      return { token: { type: "DatePattern", value: this._parseDatePattern() }, span: this.span() };
     }
 
     // Check for number (including negative)
     const nextChar = this.peekNext();
     if (isDigit(ch) || (ch === "-" && nextChar !== undefined && isDigit(nextChar))) {
-      return { token: this.#parseNumber(), span: this.span() };
+      return { token: this._parseNumber(), span: this.span() };
     }
 
     // Check for identifier/keyword
     if (isIdentStart(ch)) {
-      const start = this.#position;
+      const start = this._position;
       let ic = this.peek();
       while (ic !== undefined && isIdentContinue(ic)) {
         this.bump(1);
         ic = this.peek();
       }
-      const ident = this.#source.slice(start, this.#position);
+      const ident = this._source.slice(start, this._position);
 
       // Check for keywords
       const keyword = KEYWORDS.get(ident);

package/src/pattern/leaf/array-pattern.ts

@@ -44,10 +44,10 @@ export type ArrayPatternType =
  * Corresponds to the Rust `ArrayPattern` struct in array_pattern.rs
  */
 export class ArrayPattern implements Matcher {
-  readonly #pattern: ArrayPatternType;
+  private readonly _pattern: ArrayPatternType;
 
   private constructor(pattern: ArrayPatternType) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -93,7 +93,7 @@ export class ArrayPattern implements Matcher {
    * Gets the pattern type.
    */
   get pattern(): ArrayPatternType {
-    return this.#pattern;
+    return this._pattern;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -109,13 +109,13 @@ export class ArrayPattern implements Matcher {
       return [[], new Map<string, Path[]>()];
     }
 
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return [[[haystack]], new Map<string, Path[]>()];
 
       case "Interval": {
         const length = array.length;
-        if (this.#pattern.interval.contains(length)) {
+        if (this._pattern.interval.contains(length)) {
           return [[[haystack]], new Map<string, Path[]>()];
         }
         return [[], new Map<string, Path[]>()];
@@ -124,7 +124,7 @@ export class ArrayPattern implements Matcher {
       case "DCBORPattern": {
         // Delegate to dcbor-pattern for matching
         const { paths: dcborPaths, captures: dcborCaptures } = dcborPatternPathsWithCaptures(
-          this.#pattern.pattern,
+          this._pattern.pattern,
           cbor,
         );
 
@@ -167,7 +167,7 @@ export class ArrayPattern implements Matcher {
       case "WithPatterns":
         // For envelope patterns, match if array length equals patterns count
         // Full element-by-element matching would require additional implementation
-        if (array.length === this.#pattern.patterns.length) {
+        if (array.length === this._pattern.patterns.length) {
           return [[[haystack]], new Map<string, Path[]>()];
         }
         return [[], new Map<string, Path[]>()];
@@ -194,15 +194,15 @@ export class ArrayPattern implements Matcher {
   }
 
   toString(): string {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return "[*]";
       case "Interval":
-        return `[{${this.#pattern.interval.toString()}}]`;
+        return `[{${this._pattern.interval.toString()}}]`;
       case "DCBORPattern":
-        return dcborPatternDisplay(this.#pattern.pattern);
+        return dcborPatternDisplay(this._pattern.pattern);
       case "WithPatterns":
-        return `[${this.#pattern.patterns.map(String).join(", ")}]`;
+        return `[${this._pattern.patterns.map(String).join(", ")}]`;
     }
   }
 
@@ -210,30 +210,30 @@ export class ArrayPattern implements Matcher {
    * Equality comparison.
    */
   equals(other: ArrayPattern): boolean {
-    if (this.#pattern.type !== other.#pattern.type) {
+    if (this._pattern.type !== other._pattern.type) {
       return false;
     }
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return true;
       case "Interval":
-        return this.#pattern.interval.equals(
-          (other.#pattern as { type: "Interval"; interval: Interval }).interval,
+        return this._pattern.interval.equals(
+          (other._pattern as { type: "Interval"; interval: Interval }).interval,
         );
       case "DCBORPattern":
         // Compare using display representation
         return (
-          dcborPatternDisplay(this.#pattern.pattern) ===
+          dcborPatternDisplay(this._pattern.pattern) ===
           dcborPatternDisplay(
-            (other.#pattern as { type: "DCBORPattern"; pattern: DCBORPattern }).pattern,
+            (other._pattern as { type: "DCBORPattern"; pattern: DCBORPattern }).pattern,
           )
         );
       case "WithPatterns": {
-        const otherPatterns = (other.#pattern as { type: "WithPatterns"; patterns: Pattern[] })
+        const otherPatterns = (other._pattern as { type: "WithPatterns"; patterns: Pattern[] })
           .patterns;
-        if (this.#pattern.patterns.length !== otherPatterns.length) return false;
-        for (let i = 0; i < this.#pattern.patterns.length; i++) {
-          if (this.#pattern.patterns[i] !== otherPatterns[i]) return false;
+        if (this._pattern.patterns.length !== otherPatterns.length) return false;
+        for (let i = 0; i < this._pattern.patterns.length; i++) {
+          if (this._pattern.patterns[i] !== otherPatterns[i]) return false;
         }
         return true;
       }
@@ -244,17 +244,17 @@ export class ArrayPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return 0;
       case "Interval":
         // Simple hash based on min/max
-        return this.#pattern.interval.min() * 31 + (this.#pattern.interval.max() ?? 0);
+        return this._pattern.interval.min() * 31 + (this._pattern.interval.max() ?? 0);
       case "DCBORPattern":
         // Simple hash based on display string
-        return simpleStringHash(dcborPatternDisplay(this.#pattern.pattern));
+        return simpleStringHash(dcborPatternDisplay(this._pattern.pattern));
       case "WithPatterns":
-        return this.#pattern.patterns.length;
+        return this._pattern.patterns.length;
     }
   }
 }

package/src/pattern/leaf/bool-pattern.ts

@@ -36,10 +36,10 @@ export function registerBoolPatternFactory(factory: (pattern: BoolPattern) => Pa
  * Corresponds to the Rust `BoolPattern` struct in bool_pattern.rs
  */
 export class BoolPattern implements Matcher {
-  readonly #inner: DCBORBoolPattern;
+  private readonly _inner: DCBORBoolPattern;
 
   private constructor(inner: DCBORBoolPattern) {
-    this.#inner = inner;
+    this._inner = inner;
   }
 
   /**
@@ -67,7 +67,7 @@ export class BoolPattern implements Matcher {
    * Gets the underlying dcbor-pattern BoolPattern.
    */
   get inner(): DCBORBoolPattern {
-    return this.#inner;
+    return this._inner;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -75,7 +75,7 @@ export class BoolPattern implements Matcher {
     const cbor = haystack.asLeaf();
     if (cbor !== undefined) {
       // Delegate to dcbor-pattern for CBOR matching
-      const dcborPaths = dcborBoolPatternPaths(this.#inner, cbor);
+      const dcborPaths = dcborBoolPatternPaths(this._inner, cbor);
 
       // For simple leaf patterns, if dcbor-pattern found matches, return the envelope
       if (dcborPaths.length > 0) {
@@ -109,7 +109,7 @@ export class BoolPattern implements Matcher {
   }
 
   toString(): string {
-    return boolPatternDisplay(this.#inner);
+    return boolPatternDisplay(this._inner);
   }
 
   /**
@@ -117,11 +117,11 @@ export class BoolPattern implements Matcher {
    */
   equals(other: BoolPattern): boolean {
     // Compare by variant and value
-    if (this.#inner.variant !== other.#inner.variant) {
+    if (this._inner.variant !== other._inner.variant) {
       return false;
     }
-    if (this.#inner.variant === "Value" && other.#inner.variant === "Value") {
-      return this.#inner.value === other.#inner.value;
+    if (this._inner.variant === "Value" && other._inner.variant === "Value") {
+      return this._inner.value === other._inner.value;
     }
     return true;
   }
@@ -131,9 +131,9 @@ export class BoolPattern implements Matcher {
    */
   hashCode(): number {
     // Simple hash based on variant and value
-    let hash = this.#inner.variant === "Any" ? 0 : 1;
-    if (this.#inner.variant === "Value") {
-      hash = hash * 31 + (this.#inner.value ? 1 : 0);
+    let hash = this._inner.variant === "Any" ? 0 : 1;
+    if (this._inner.variant === "Value") {
+      hash = hash * 31 + (this._inner.value ? 1 : 0);
     }
     return hash;
   }