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

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

@@ -44,10 +44,10 @@ export function registerNumberPatternFactory(factory: (pattern: NumberPattern) =
  * Corresponds to the Rust `NumberPattern` struct in number_pattern.rs
  */
 export class NumberPattern implements Matcher {
-  readonly #inner: DCBORNumberPattern;
+  private readonly _inner: DCBORNumberPattern;
 
   private constructor(inner: DCBORNumberPattern) {
-    this.#inner = inner;
+    this._inner = inner;
   }
 
   /**
@@ -131,7 +131,7 @@ export class NumberPattern implements Matcher {
    * Gets the underlying dcbor-pattern NumberPattern.
    */
   get inner(): DCBORNumberPattern {
-    return this.#inner;
+    return this._inner;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -139,7 +139,7 @@ export class NumberPattern implements Matcher {
     const cbor = haystack.asLeaf();
     if (cbor !== undefined) {
       // Delegate to dcbor-pattern for CBOR matching
-      const dcborPaths = dcborNumberPatternPaths(this.#inner, cbor);
+      const dcborPaths = dcborNumberPatternPaths(this._inner, cbor);
 
       // For simple leaf patterns, if dcbor-pattern found matches, return the envelope
       if (dcborPaths.length > 0) {
@@ -171,7 +171,7 @@ export class NumberPattern implements Matcher {
   }
 
   toString(): string {
-    return numberPatternDisplay(this.#inner);
+    return numberPatternDisplay(this._inner);
   }
 
   /**
@@ -179,10 +179,10 @@ export class NumberPattern implements Matcher {
    */
   equals(other: NumberPattern): boolean {
     // Compare by variant and values
-    if (this.#inner.variant !== other.#inner.variant) {
+    if (this._inner.variant !== other._inner.variant) {
       return false;
     }
-    switch (this.#inner.variant) {
+    switch (this._inner.variant) {
       case "Any":
       case "NaN":
       case "Infinity":
@@ -194,14 +194,14 @@ export class NumberPattern implements Matcher {
       case "LessThan":
       case "LessThanOrEqual":
         return (
-          (this.#inner as { value: number }).value === (other.#inner as { value: number }).value
+          (this._inner as { value: number }).value === (other._inner as { value: number }).value
         );
       case "Range":
         return (
-          (this.#inner as { min: number; max: number }).min ===
-            (other.#inner as { min: number; max: number }).min &&
-          (this.#inner as { min: number; max: number }).max ===
-            (other.#inner as { min: number; max: number }).max
+          (this._inner as { min: number; max: number }).min ===
+            (other._inner as { min: number; max: number }).min &&
+          (this._inner as { min: number; max: number }).max ===
+            (other._inner as { min: number; max: number }).max
         );
     }
   }
@@ -211,27 +211,27 @@ export class NumberPattern implements Matcher {
    */
   hashCode(): number {
     let hash = 0;
-    switch (this.#inner.variant) {
+    switch (this._inner.variant) {
       case "Any":
         hash = 1;
         break;
       case "Value":
-        hash = 2 * 31 + (this.#inner as { value: number }).value;
+        hash = 2 * 31 + (this._inner as { value: number }).value;
         break;
       case "Range":
-        hash = 3 * 31 + (this.#inner as { min: number }).min + (this.#inner as { max: number }).max;
+        hash = 3 * 31 + (this._inner as { min: number }).min + (this._inner as { max: number }).max;
         break;
       case "GreaterThan":
-        hash = 4 * 31 + (this.#inner as { value: number }).value;
+        hash = 4 * 31 + (this._inner as { value: number }).value;
         break;
       case "GreaterThanOrEqual":
-        hash = 5 * 31 + (this.#inner as { value: number }).value;
+        hash = 5 * 31 + (this._inner as { value: number }).value;
         break;
       case "LessThan":
-        hash = 6 * 31 + (this.#inner as { value: number }).value;
+        hash = 6 * 31 + (this._inner as { value: number }).value;
         break;
       case "LessThanOrEqual":
-        hash = 7 * 31 + (this.#inner as { value: number }).value;
+        hash = 7 * 31 + (this._inner as { value: number }).value;
         break;
       case "NaN":
         hash = 8;

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

@@ -41,10 +41,10 @@ export function registerTaggedPatternFactory(factory: (pattern: TaggedPattern) =
  * Corresponds to the Rust `TaggedPattern` struct in tagged_pattern.rs
  */
 export class TaggedPattern implements Matcher {
-  readonly #inner: DCBORTaggedPattern;
+  private readonly _inner: DCBORTaggedPattern;
 
   private constructor(inner: DCBORTaggedPattern) {
-    this.#inner = inner;
+    this._inner = inner;
   }
 
   /**
@@ -86,7 +86,7 @@ export class TaggedPattern implements Matcher {
    * Gets the underlying dcbor-pattern TaggedPattern.
    */
   get inner(): DCBORTaggedPattern {
-    return this.#inner;
+    return this._inner;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -96,7 +96,7 @@ export class TaggedPattern implements Matcher {
 
     if (cbor !== undefined) {
       // Delegate to dcbor-pattern for CBOR matching
-      const [dcborPaths, dcborCaptures] = taggedPatternPathsWithCaptures(this.#inner, cbor);
+      const [dcborPaths, dcborCaptures] = taggedPatternPathsWithCaptures(this._inner, cbor);
 
       if (dcborPaths.length > 0) {
         // Convert dcbor paths to envelope paths
@@ -155,7 +155,7 @@ export class TaggedPattern implements Matcher {
   }
 
   toString(): string {
-    return taggedPatternDisplay(this.#inner, patternDisplay);
+    return taggedPatternDisplay(this._inner, patternDisplay);
   }
 
   /**
@@ -163,35 +163,35 @@ export class TaggedPattern implements Matcher {
    */
   equals(other: TaggedPattern): boolean {
     // Compare by variant type and values
-    if (this.#inner.variant !== other.#inner.variant) {
+    if (this._inner.variant !== other._inner.variant) {
       return false;
     }
-    switch (this.#inner.variant) {
+    switch (this._inner.variant) {
       case "Any":
         return true;
       case "Tag": {
-        const otherTag = other.#inner as { variant: "Tag"; tag: Tag; pattern: DCBORPattern };
+        const otherTag = other._inner as { variant: "Tag"; tag: Tag; pattern: DCBORPattern };
         return (
-          this.#inner.tag.value === otherTag.tag.value &&
-          patternDisplay(this.#inner.pattern) === patternDisplay(otherTag.pattern)
+          this._inner.tag.value === otherTag.tag.value &&
+          patternDisplay(this._inner.pattern) === patternDisplay(otherTag.pattern)
         );
       }
       case "Name": {
-        const otherName = other.#inner as { variant: "Name"; name: string; pattern: DCBORPattern };
+        const otherName = other._inner as { variant: "Name"; name: string; pattern: DCBORPattern };
         return (
-          this.#inner.name === otherName.name &&
-          patternDisplay(this.#inner.pattern) === patternDisplay(otherName.pattern)
+          this._inner.name === otherName.name &&
+          patternDisplay(this._inner.pattern) === patternDisplay(otherName.pattern)
         );
       }
       case "Regex": {
-        const otherRegex = other.#inner as {
+        const otherRegex = other._inner as {
           variant: "Regex";
           regex: RegExp;
           pattern: DCBORPattern;
         };
         return (
-          this.#inner.regex.source === otherRegex.regex.source &&
-          patternDisplay(this.#inner.pattern) === patternDisplay(otherRegex.pattern)
+          this._inner.regex.source === otherRegex.regex.source &&
+          patternDisplay(this._inner.pattern) === patternDisplay(otherRegex.pattern)
         );
       }
     }
@@ -201,15 +201,15 @@ export class TaggedPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    switch (this.#inner.variant) {
+    switch (this._inner.variant) {
       case "Any":
         return 0;
       case "Tag":
-        return Number(BigInt(this.#inner.tag.value) & BigInt(0xffffffff));
+        return Number(BigInt(this._inner.tag.value) & BigInt(0xffffffff));
       case "Name":
-        return simpleStringHash(this.#inner.name);
+        return simpleStringHash(this._inner.name);
       case "Regex":
-        return simpleStringHash(this.#inner.regex.source);
+        return simpleStringHash(this._inner.regex.source);
     }
   }
 }

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

@@ -37,10 +37,10 @@ export function registerTextPatternFactory(factory: (pattern: TextPattern) => Pa
  * Corresponds to the Rust `TextPattern` struct in text_pattern.rs
  */
 export class TextPattern implements Matcher {
-  readonly #inner: DCBORTextPattern;
+  private readonly _inner: DCBORTextPattern;
 
   private constructor(inner: DCBORTextPattern) {
-    this.#inner = inner;
+    this._inner = inner;
   }
 
   /**
@@ -75,7 +75,7 @@ export class TextPattern implements Matcher {
    * Gets the underlying dcbor-pattern TextPattern.
    */
   get inner(): DCBORTextPattern {
-    return this.#inner;
+    return this._inner;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -83,7 +83,7 @@ export class TextPattern implements Matcher {
     const cbor = haystack.asLeaf();
     if (cbor !== undefined) {
       // Delegate to dcbor-pattern for CBOR matching
-      const dcborPaths = dcborTextPatternPaths(this.#inner, cbor);
+      const dcborPaths = dcborTextPatternPaths(this._inner, cbor);
 
       // For simple leaf patterns, if dcbor-pattern found matches, return the envelope
       if (dcborPaths.length > 0) {
@@ -115,27 +115,27 @@ export class TextPattern implements Matcher {
   }
 
   toString(): string {
-    return textPatternDisplay(this.#inner);
+    return textPatternDisplay(this._inner);
   }
 
   /**
    * Equality comparison.
    */
   equals(other: TextPattern): boolean {
-    if (this.#inner.variant !== other.#inner.variant) {
+    if (this._inner.variant !== other._inner.variant) {
       return false;
     }
-    switch (this.#inner.variant) {
+    switch (this._inner.variant) {
       case "Any":
         return true;
       case "Value":
         return (
-          (this.#inner as { value: string }).value === (other.#inner as { value: string }).value
+          (this._inner as { value: string }).value === (other._inner as { value: string }).value
         );
       case "Regex":
         return (
-          (this.#inner as { pattern: RegExp }).pattern.source ===
-          (other.#inner as { pattern: RegExp }).pattern.source
+          (this._inner as { pattern: RegExp }).pattern.source ===
+          (other._inner as { pattern: RegExp }).pattern.source
         );
     }
   }
@@ -145,19 +145,19 @@ export class TextPattern implements Matcher {
    */
   hashCode(): number {
     let hash = 0;
-    switch (this.#inner.variant) {
+    switch (this._inner.variant) {
       case "Any":
         hash = 1;
         break;
       case "Value": {
-        const val = (this.#inner as { value: string }).value;
+        const val = (this._inner as { value: string }).value;
         for (let i = 0; i < val.length; i++) {
           hash = hash * 31 + val.charCodeAt(i);
         }
         break;
       }
       case "Regex":
-        hash = 3 * 31 + (this.#inner as { pattern: RegExp }).pattern.source.length;
+        hash = 3 * 31 + (this._inner as { pattern: RegExp }).pattern.source.length;
         break;
     }
     return hash;

package/src/pattern/meta/and-pattern.ts

@@ -25,10 +25,10 @@ export function registerAndPatternFactory(factory: (pattern: AndPattern) => Patt
  * Corresponds to the Rust `AndPattern` struct in and_pattern.rs
  */
 export class AndPattern implements Matcher {
-  readonly #patterns: Pattern[];
+  private readonly _patterns: Pattern[];
 
   private constructor(patterns: Pattern[]) {
-    this.#patterns = patterns;
+    this._patterns = patterns;
   }
 
   /**
@@ -42,11 +42,11 @@ export class AndPattern implements Matcher {
    * Gets the patterns.
    */
   patterns(): Pattern[] {
-    return this.#patterns;
+    return this._patterns;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
-    const allMatch = this.#patterns.every((pattern) => matchPattern(pattern, haystack));
+    const allMatch = this._patterns.every((pattern) => matchPattern(pattern, haystack));
 
     const paths = allMatch ? [[haystack]] : [];
     return [paths, new Map<string, Path[]>()];
@@ -62,7 +62,7 @@ export class AndPattern implements Matcher {
 
   compile(code: Instr[], literals: Pattern[], captures: string[]): void {
     // Each pattern must match at this position
-    for (const pattern of this.#patterns) {
+    for (const pattern of this._patterns) {
       const matcher = pattern as unknown as Matcher;
       matcher.compile(code, literals, captures);
     }
@@ -72,12 +72,12 @@ export class AndPattern implements Matcher {
     // The pattern is complex if it contains more than one pattern, or if
     // the one pattern is complex itself.
     return (
-      this.#patterns.length > 1 || this.#patterns.some((p) => (p as unknown as Matcher).isComplex())
+      this._patterns.length > 1 || this._patterns.some((p) => (p as unknown as Matcher).isComplex())
     );
   }
 
   toString(): string {
-    return this.#patterns
+    return this._patterns
       .map((p) => (p as unknown as { toString(): string }).toString())
       .join(" & ");
   }
@@ -86,11 +86,11 @@ export class AndPattern implements Matcher {
    * Equality comparison.
    */
   equals(other: AndPattern): boolean {
-    if (this.#patterns.length !== other.#patterns.length) {
+    if (this._patterns.length !== other._patterns.length) {
       return false;
     }
-    for (let i = 0; i < this.#patterns.length; i++) {
-      if (this.#patterns[i] !== other.#patterns[i]) {
+    for (let i = 0; i < this._patterns.length; i++) {
+      if (this._patterns[i] !== other._patterns[i]) {
         return false;
       }
     }
@@ -101,6 +101,6 @@ export class AndPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    return this.#patterns.length;
+    return this._patterns.length;
   }
 }

package/src/pattern/meta/capture-pattern.ts

@@ -25,12 +25,12 @@ export function registerCapturePatternFactory(factory: (pattern: CapturePattern)
  * Corresponds to the Rust `CapturePattern` struct in capture_pattern.rs
  */
 export class CapturePattern implements Matcher {
-  readonly #name: string;
-  readonly #pattern: Pattern;
+  private readonly _name: string;
+  private readonly _pattern: Pattern;
 
   private constructor(name: string, pattern: Pattern) {
-    this.#name = name;
-    this.#pattern = pattern;
+    this._name = name;
+    this._pattern = pattern;
   }
 
   /**
@@ -44,23 +44,23 @@ export class CapturePattern implements Matcher {
    * Gets the name of the capture.
    */
   name(): string {
-    return this.#name;
+    return this._name;
   }
 
   /**
    * Gets the inner pattern.
    */
   pattern(): Pattern {
-    return this.#pattern;
+    return this._pattern;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
-    const matcher = this.#pattern as unknown as Matcher;
+    const matcher = this._pattern as unknown as Matcher;
     const [paths, caps] = matcher.pathsWithCaptures(haystack);
 
     if (paths.length > 0) {
-      const existing = caps.get(this.#name) ?? [];
-      caps.set(this.#name, [...existing, ...paths]);
+      const existing = caps.get(this._name) ?? [];
+      caps.set(this._name, [...existing, ...paths]);
     }
 
     return [paths, caps];
@@ -76,9 +76,9 @@ export class CapturePattern implements Matcher {
 
   compile(code: Instr[], literals: Pattern[], captures: string[]): void {
     const id = captures.length;
-    captures.push(this.#name);
+    captures.push(this._name);
     code.push({ type: "CaptureStart", captureIndex: id });
-    const matcher = this.#pattern as unknown as Matcher;
+    const matcher = this._pattern as unknown as Matcher;
     matcher.compile(code, literals, captures);
     code.push({ type: "CaptureEnd", captureIndex: id });
   }
@@ -88,14 +88,14 @@ export class CapturePattern implements Matcher {
   }
 
   toString(): string {
-    return `@${this.#name}(${(this.#pattern as unknown as { toString(): string }).toString()})`;
+    return `@${this._name}(${(this._pattern as unknown as { toString(): string }).toString()})`;
   }
 
   /**
    * Equality comparison.
    */
   equals(other: CapturePattern): boolean {
-    return this.#name === other.#name && this.#pattern === other.#pattern;
+    return this._name === other._name && this._pattern === other._pattern;
   }
 
   /**
@@ -103,7 +103,7 @@ export class CapturePattern implements Matcher {
    */
   hashCode(): number {
     let hash = 0;
-    for (const char of this.#name) {
+    for (const char of this._name) {
       hash = (hash * 31 + char.charCodeAt(0)) | 0;
     }
     return hash;

package/src/pattern/meta/group-pattern.ts

@@ -26,12 +26,12 @@ export function registerGroupPatternFactory(factory: (pattern: GroupPattern) =>
  * Corresponds to the Rust `GroupPattern` struct in repeat_pattern.rs
  */
 export class GroupPattern implements Matcher {
-  readonly #pattern: Pattern;
-  readonly #quantifier: Quantifier;
+  private readonly _pattern: Pattern;
+  private readonly _quantifier: Quantifier;
 
   private constructor(pattern: Pattern, quantifier: Quantifier) {
-    this.#pattern = pattern;
-    this.#quantifier = quantifier;
+    this._pattern = pattern;
+    this._quantifier = quantifier;
   }
 
   /**
@@ -52,14 +52,14 @@ export class GroupPattern implements Matcher {
    * Gets the sub-pattern of this group pattern.
    */
   pattern(): Pattern {
-    return this.#pattern;
+    return this._pattern;
   }
 
   /**
    * Gets the quantifier of this group pattern.
    */
   quantifier(): Quantifier {
-    return this.#quantifier;
+    return this._quantifier;
   }
 
   pathsWithCaptures(_haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -74,14 +74,14 @@ export class GroupPattern implements Matcher {
 
   matches(haystack: Envelope): boolean {
     // GroupPattern needs VM execution
-    const matcher = this.#pattern as unknown as Matcher;
+    const matcher = this._pattern as unknown as Matcher;
     return matcher.matches(haystack);
   }
 
   compile(code: Instr[], literals: Pattern[], _captures: string[]): void {
     const idx = literals.length;
-    literals.push(this.#pattern);
-    code.push({ type: "Repeat", patternIndex: idx, quantifier: this.#quantifier });
+    literals.push(this._pattern);
+    code.push({ type: "Repeat", patternIndex: idx, quantifier: this._quantifier });
   }
 
   isComplex(): boolean {
@@ -89,15 +89,15 @@ export class GroupPattern implements Matcher {
   }
 
   toString(): string {
-    const formattedRange = this.#quantifier.toString();
-    return `(${(this.#pattern as unknown as { toString(): string }).toString()})${formattedRange}`;
+    const formattedRange = this._quantifier.toString();
+    return `(${(this._pattern as unknown as { toString(): string }).toString()})${formattedRange}`;
   }
 
   /**
    * Equality comparison.
    */
   equals(other: GroupPattern): boolean {
-    return this.#pattern === other.#pattern && this.#quantifier.equals(other.#quantifier);
+    return this._pattern === other._pattern && this._quantifier.equals(other._quantifier);
   }
 
   /**
@@ -105,6 +105,6 @@ export class GroupPattern implements Matcher {
    */
   hashCode(): number {
     // Simple hash based on quantifier min/max
-    return this.#quantifier.min() * 31 + (this.#quantifier.max() ?? 0);
+    return this._quantifier.min() * 31 + (this._quantifier.max() ?? 0);
   }
 }

package/src/pattern/meta/not-pattern.ts

@@ -25,10 +25,10 @@ export function registerNotPatternFactory(factory: (pattern: NotPattern) => Patt
  * Corresponds to the Rust `NotPattern` struct in not_pattern.rs
  */
 export class NotPattern implements Matcher {
-  readonly #pattern: Pattern;
+  private readonly _pattern: Pattern;
 
   private constructor(pattern: Pattern) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -42,12 +42,12 @@ export class NotPattern implements Matcher {
    * Gets the inner pattern.
    */
   pattern(): Pattern {
-    return this.#pattern;
+    return this._pattern;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
     // If the inner pattern doesn't match, then we return the current envelope as a match
-    const paths = !matchPattern(this.#pattern, haystack) ? [[haystack]] : [];
+    const paths = !matchPattern(this._pattern, haystack) ? [[haystack]] : [];
     return [paths, new Map<string, Path[]>()];
   }
 
@@ -62,7 +62,7 @@ export class NotPattern implements Matcher {
   compile(code: Instr[], literals: Pattern[], _captures: string[]): void {
     // NOT = check that pattern doesn't match
     const idx = literals.length;
-    literals.push(this.#pattern);
+    literals.push(this._pattern);
     code.push({ type: "NotMatch", patternIndex: idx });
   }
 
@@ -71,14 +71,14 @@ export class NotPattern implements Matcher {
   }
 
   toString(): string {
-    return `!${(this.#pattern as unknown as { toString(): string }).toString()}`;
+    return `!${(this._pattern as unknown as { toString(): string }).toString()}`;
   }
 
   /**
    * Equality comparison.
    */
   equals(other: NotPattern): boolean {
-    return this.#pattern === other.#pattern;
+    return this._pattern === other._pattern;
   }
 
   /**