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

package/src/pattern/leaf/byte-string-pattern.ts

@@ -39,10 +39,10 @@ export function registerByteStringPatternFactory(
  * Corresponds to the Rust `ByteStringPattern` struct in byte_string_pattern.rs
  */
 export class ByteStringPattern implements Matcher {
-  readonly #inner: DCBORByteStringPattern;
+  private readonly _inner: DCBORByteStringPattern;
 
   private constructor(inner: DCBORByteStringPattern) {
-    this.#inner = inner;
+    this._inner = inner;
   }
 
   /**
@@ -77,7 +77,7 @@ export class ByteStringPattern implements Matcher {
    * Gets the underlying dcbor-pattern ByteStringPattern.
    */
   get inner(): DCBORByteStringPattern {
-    return this.#inner;
+    return this._inner;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -85,7 +85,7 @@ export class ByteStringPattern implements Matcher {
     const cbor = haystack.asLeaf();
     if (cbor !== undefined) {
       // Delegate to dcbor-pattern for CBOR matching
-      const dcborPaths = dcborByteStringPatternPaths(this.#inner, cbor);
+      const dcborPaths = dcborByteStringPatternPaths(this._inner, cbor);
 
       // For simple leaf patterns, if dcbor-pattern found matches, return the envelope
       if (dcborPaths.length > 0) {
@@ -117,22 +117,22 @@ export class ByteStringPattern implements Matcher {
   }
 
   toString(): string {
-    return byteStringPatternDisplay(this.#inner);
+    return byteStringPatternDisplay(this._inner);
   }
 
   /**
    * Equality comparison.
    */
   equals(other: ByteStringPattern): 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": {
-        const a = (this.#inner as { value: Uint8Array }).value;
-        const b = (other.#inner as { value: Uint8Array }).value;
+        const a = (this._inner as { value: Uint8Array }).value;
+        const b = (other._inner as { value: Uint8Array }).value;
         if (a.length !== b.length) return false;
         for (let i = 0; i < a.length; i++) {
           if (a[i] !== b[i]) return false;
@@ -141,8 +141,8 @@ export class ByteStringPattern implements Matcher {
       }
       case "BinaryRegex":
         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
         );
     }
   }
@@ -152,19 +152,19 @@ export class ByteStringPattern 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: Uint8Array }).value;
+        const val = (this._inner as { value: Uint8Array }).value;
         for (const byte of val) {
           hash = hash * 31 + byte;
         }
         break;
       }
       case "BinaryRegex":
-        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/leaf/cbor-pattern.ts

@@ -43,10 +43,10 @@ export type CBORPatternType =
  * Corresponds to the Rust `CBORPattern` enum in cbor_pattern.rs
  */
 export class CBORPattern implements Matcher {
-  readonly #pattern: CBORPatternType;
+  private readonly _pattern: CBORPatternType;
 
   private constructor(pattern: CBORPatternType) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -81,13 +81,13 @@ export class CBORPattern implements Matcher {
    * Gets the pattern type.
    */
   get pattern(): CBORPatternType {
-    return this.#pattern;
+    return this._pattern;
   }
 
   /**
    * Convert dcbor captures to envelope captures.
    */
-  #convertDcborCapturesToEnvelopeCaptures(
+  private _convertDcborCapturesToEnvelopeCaptures(
     dcborCaptures: Map<string, Cbor[][]>,
     baseEnvelope: Envelope,
     baseCbor: Cbor,
@@ -96,7 +96,7 @@ export class CBORPattern implements Matcher {
 
     for (const [captureName, dcborCapturePaths] of dcborCaptures) {
       const envelopeCapturePaths: Path[] = dcborCapturePaths.map((dcborPath) =>
-        this.#convertDcborPathToEnvelopePath(dcborPath, baseEnvelope, baseCbor),
+        this._convertDcborPathToEnvelopePath(dcborPath, baseEnvelope, baseCbor),
       );
       envelopeCaptures.set(captureName, envelopeCapturePaths);
     }
@@ -107,7 +107,7 @@ export class CBORPattern implements Matcher {
   /**
    * Convert a single dcbor path to an envelope path.
    */
-  #convertDcborPathToEnvelopePath(
+  private _convertDcborPathToEnvelopePath(
     dcborPath: Cbor[],
     baseEnvelope: Envelope,
     baseCbor: Cbor,
@@ -131,7 +131,7 @@ export class CBORPattern implements Matcher {
   /**
    * Collect capture names from a dcbor pattern.
    */
-  #collectDcborCaptureNames(dcborPattern: DCBORPattern, names: string[]): void {
+  private _collectDcborCaptureNames(dcborPattern: DCBORPattern, names: string[]): void {
     // Parse the pattern string to extract capture names
     const patternStr = dcborPatternDisplay(dcborPattern);
 
@@ -163,19 +163,19 @@ export class CBORPattern implements Matcher {
       const knownValue = envCase.value;
       const knownValueCbor = knownValue.taggedCbor();
 
-      switch (this.#pattern.type) {
+      switch (this._pattern.type) {
         case "Any":
           return [[[haystack]], new Map<string, Path[]>()];
         case "Value": {
           // Compare using diagnostic representation
-          if (knownValueCbor.toDiagnostic() === this.#pattern.cbor.toDiagnostic()) {
+          if (knownValueCbor.toDiagnostic() === this._pattern.cbor.toDiagnostic()) {
             return [[[haystack]], new Map<string, Path[]>()];
           }
           return [[], new Map<string, Path[]>()];
         }
         case "Pattern": {
           const { paths: dcborPaths, captures: dcborCaptures } = dcborPatternPathsWithCaptures(
-            this.#pattern.pattern,
+            this._pattern.pattern,
             knownValueCbor,
           );
 
@@ -193,7 +193,7 @@ export class CBORPattern implements Matcher {
               return extendedPath;
             });
 
-            const envelopeCaptures = this.#convertDcborCapturesToEnvelopeCaptures(
+            const envelopeCaptures = this._convertDcborCapturesToEnvelopeCaptures(
               dcborCaptures,
               haystack,
               knownValueCbor,
@@ -211,20 +211,20 @@ export class CBORPattern implements Matcher {
       return [[], new Map<string, Path[]>()];
     }
 
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return [[[haystack]], new Map<string, Path[]>()];
 
       case "Value":
         // Compare using diagnostic representation
-        if (leafCbor.toDiagnostic() === this.#pattern.cbor.toDiagnostic()) {
+        if (leafCbor.toDiagnostic() === this._pattern.cbor.toDiagnostic()) {
           return [[[haystack]], new Map<string, Path[]>()];
         }
         return [[], new Map<string, Path[]>()];
 
       case "Pattern": {
         const { paths: dcborPaths, captures: dcborCaptures } = dcborPatternPathsWithCaptures(
-          this.#pattern.pattern,
+          this._pattern.pattern,
           leafCbor,
         );
 
@@ -245,7 +245,7 @@ export class CBORPattern implements Matcher {
             return extendedPath;
           });
 
-          const envelopeCaptures = this.#convertDcborCapturesToEnvelopeCaptures(
+          const envelopeCaptures = this._convertDcborCapturesToEnvelopeCaptures(
             dcborCaptures,
             haystack,
             leafCbor,
@@ -267,9 +267,9 @@ export class CBORPattern implements Matcher {
 
   compile(code: Instr[], literals: Pattern[], captures: string[]): void {
     // Register any capture names from this CBOR pattern
-    if (this.#pattern.type === "Pattern") {
+    if (this._pattern.type === "Pattern") {
       const captureNames: string[] = [];
-      this.#collectDcborCaptureNames(this.#pattern.pattern, captureNames);
+      this._collectDcborCaptureNames(this._pattern.pattern, captureNames);
       for (const name of captureNames) {
         if (!captures.includes(name)) {
           captures.push(name);
@@ -288,13 +288,13 @@ export class CBORPattern implements Matcher {
   }
 
   toString(): string {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return "cbor";
       case "Value":
-        return `cbor(${this.#pattern.cbor.toDiagnostic()})`;
+        return `cbor(${this._pattern.cbor.toDiagnostic()})`;
       case "Pattern":
-        return `cbor(/${dcborPatternDisplay(this.#pattern.pattern)}/)`;
+        return `cbor(/${dcborPatternDisplay(this._pattern.pattern)}/)`;
     }
   }
 
@@ -302,24 +302,24 @@ export class CBORPattern implements Matcher {
    * Equality comparison.
    */
   equals(other: CBORPattern): 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 "Value":
         // Compare using diagnostic representation
         return (
-          this.#pattern.cbor.toDiagnostic() ===
-          (other.#pattern as { type: "Value"; cbor: Cbor }).cbor.toDiagnostic()
+          this._pattern.cbor.toDiagnostic() ===
+          (other._pattern as { type: "Value"; cbor: Cbor }).cbor.toDiagnostic()
         );
       case "Pattern":
         // Compare using display representation
         return (
-          dcborPatternDisplay(this.#pattern.pattern) ===
+          dcborPatternDisplay(this._pattern.pattern) ===
           dcborPatternDisplay(
-            (other.#pattern as { type: "Pattern"; pattern: DCBORPattern }).pattern,
+            (other._pattern as { type: "Pattern"; pattern: DCBORPattern }).pattern,
           )
         );
     }
@@ -329,15 +329,15 @@ export class CBORPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return 0;
       case "Value":
         // Simple hash based on diagnostic string
-        return simpleStringHash(this.#pattern.cbor.toDiagnostic());
+        return simpleStringHash(this._pattern.cbor.toDiagnostic());
       case "Pattern":
         // Simple hash based on display string
-        return simpleStringHash(dcborPatternDisplay(this.#pattern.pattern));
+        return simpleStringHash(dcborPatternDisplay(this._pattern.pattern));
     }
   }
 }

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

@@ -42,10 +42,10 @@ export function registerDatePatternFactory(factory: (pattern: DatePattern) => Pa
  * Corresponds to the Rust `DatePattern` struct in date_pattern.rs
  */
 export class DatePattern implements Matcher {
-  readonly #inner: DCBORDatePattern;
+  private readonly _inner: DCBORDatePattern;
 
   private constructor(inner: DCBORDatePattern) {
-    this.#inner = inner;
+    this._inner = inner;
   }
 
   /**
@@ -109,7 +109,7 @@ export class DatePattern implements Matcher {
    * Gets the underlying dcbor-pattern DatePattern.
    */
   get inner(): DCBORDatePattern {
-    return this.#inner;
+    return this._inner;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -117,7 +117,7 @@ export class DatePattern implements Matcher {
     const cbor = haystack.asLeaf();
     if (cbor !== undefined) {
       // Delegate to dcbor-pattern for CBOR matching
-      const dcborPaths = dcborDatePatternPaths(this.#inner, cbor);
+      const dcborPaths = dcborDatePatternPaths(this._inner, cbor);
 
       // For simple leaf patterns, if dcbor-pattern found matches, return the envelope
       if (dcborPaths.length > 0) {
@@ -149,18 +149,18 @@ export class DatePattern implements Matcher {
   }
 
   toString(): string {
-    return datePatternDisplay(this.#inner);
+    return datePatternDisplay(this._inner);
   }
 
   /**
    * Equality comparison.
    */
   equals(other: DatePattern): boolean {
-    if (this.#inner.variant !== other.#inner.variant) {
+    if (this._inner.variant !== other._inner.variant) {
       return false;
     }
     // Simplified equality - compare variant names
-    return JSON.stringify(this.#inner) === JSON.stringify(other.#inner);
+    return JSON.stringify(this._inner) === JSON.stringify(other._inner);
   }
 
   /**
@@ -169,7 +169,7 @@ export class DatePattern implements Matcher {
   hashCode(): number {
     // Simple hash based on variant
     let hash = 0;
-    const str = this.#inner.variant;
+    const str = this._inner.variant;
     for (let i = 0; i < str.length; i++) {
       hash = hash * 31 + str.charCodeAt(i);
     }

package/src/pattern/leaf/known-value-pattern.ts

@@ -41,10 +41,10 @@ export function registerKnownValuePatternFactory(
  * Corresponds to the Rust `KnownValuePattern` struct in known_value_pattern.rs
  */
 export class KnownValuePattern implements Matcher {
-  readonly #inner: DCBORKnownValuePattern;
+  private readonly _inner: DCBORKnownValuePattern;
 
   private constructor(inner: DCBORKnownValuePattern) {
-    this.#inner = inner;
+    this._inner = inner;
   }
 
   /**
@@ -86,7 +86,7 @@ export class KnownValuePattern implements Matcher {
    * Gets the underlying dcbor-pattern KnownValuePattern.
    */
   get inner(): DCBORKnownValuePattern {
-    return this.#inner;
+    return this._inner;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -96,7 +96,7 @@ export class KnownValuePattern implements Matcher {
     if (envCase.type === "knownValue") {
       // Get the KnownValue and create CBOR for pattern matching
       const knownValueCbor = envCase.value.taggedCbor();
-      if (knownValuePatternMatches(this.#inner, knownValueCbor)) {
+      if (knownValuePatternMatches(this._inner, knownValueCbor)) {
         return [[[haystack]], new Map<string, Path[]>()];
       }
     }
@@ -104,7 +104,7 @@ export class KnownValuePattern implements Matcher {
     // Also try matching as a leaf (for tagged CBOR containing known values)
     const leafCbor = haystack.asLeaf();
     if (leafCbor !== undefined) {
-      if (knownValuePatternMatches(this.#inner, leafCbor)) {
+      if (knownValuePatternMatches(this._inner, leafCbor)) {
         return [[[haystack]], new Map<string, Path[]>()];
       }
     }
@@ -132,7 +132,7 @@ export class KnownValuePattern implements Matcher {
   }
 
   toString(): string {
-    return knownValuePatternDisplay(this.#inner);
+    return knownValuePatternDisplay(this._inner);
   }
 
   /**
@@ -140,23 +140,23 @@ export class KnownValuePattern implements Matcher {
    */
   equals(other: KnownValuePattern): 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 "Value":
         return (
-          this.#inner.value.valueBigInt() ===
-          (other.#inner as { variant: "Value"; value: KnownValue }).value.valueBigInt()
+          this._inner.value.valueBigInt() ===
+          (other._inner as { variant: "Value"; value: KnownValue }).value.valueBigInt()
         );
       case "Named":
-        return this.#inner.name === (other.#inner as { variant: "Named"; name: string }).name;
+        return this._inner.name === (other._inner as { variant: "Named"; name: string }).name;
       case "Regex":
         return (
-          this.#inner.pattern.source ===
-          (other.#inner as { variant: "Regex"; pattern: RegExp }).pattern.source
+          this._inner.pattern.source ===
+          (other._inner as { variant: "Regex"; pattern: RegExp }).pattern.source
         );
     }
   }
@@ -165,15 +165,15 @@ export class KnownValuePattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    switch (this.#inner.variant) {
+    switch (this._inner.variant) {
       case "Any":
         return 0;
       case "Value":
-        return Number(this.#inner.value.valueBigInt() & BigInt(0xffffffff));
+        return Number(this._inner.value.valueBigInt() & BigInt(0xffffffff));
       case "Named":
-        return simpleStringHash(this.#inner.name);
+        return simpleStringHash(this._inner.name);
       case "Regex":
-        return simpleStringHash(this.#inner.pattern.source);
+        return simpleStringHash(this._inner.pattern.source);
     }
   }
 }

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

@@ -37,10 +37,10 @@ export type MapPatternType =
  * Corresponds to the Rust `MapPattern` struct in map_pattern.rs
  */
 export class MapPattern implements Matcher {
-  readonly #pattern: MapPatternType;
+  private readonly _pattern: MapPatternType;
 
   private constructor(pattern: MapPatternType) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -62,7 +62,7 @@ export class MapPattern implements Matcher {
    * Gets the pattern type.
    */
   get pattern(): MapPatternType {
-    return this.#pattern;
+    return this._pattern;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -78,13 +78,13 @@ export class MapPattern 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 size = map.size;
-        if (this.#pattern.interval.contains(size)) {
+        if (this._pattern.interval.contains(size)) {
           return [[[haystack]], new Map<string, Path[]>()];
         }
         return [[], new Map<string, Path[]>()];
@@ -112,11 +112,11 @@ export class MapPattern 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()}}}`;
     }
   }
 
@@ -124,15 +124,15 @@ export class MapPattern implements Matcher {
    * Equality comparison.
    */
   equals(other: MapPattern): 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,
         );
     }
   }
@@ -141,12 +141,12 @@ export class MapPattern 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 interval min/max
-        return this.#pattern.interval.min() * 31 + (this.#pattern.interval.max() ?? 0);
+        return this._pattern.interval.min() * 31 + (this._pattern.interval.max() ?? 0);
     }
   }
 }

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

@@ -34,26 +34,26 @@ export function registerNullPatternFactory(factory: (pattern: NullPattern) => Pa
  * Corresponds to the Rust `NullPattern` struct in null_pattern.rs
  */
 export class NullPattern implements Matcher {
-  readonly #inner: DCBORNullPattern;
-  static readonly #instance = new NullPattern();
+  private readonly _inner: DCBORNullPattern;
+  private static readonly _instance = new NullPattern();
 
   private constructor() {
     // Create the NullPattern directly - it's just { variant: "Null" }
-    this.#inner = { variant: "Null" };
+    this._inner = { variant: "Null" };
   }
 
   /**
    * Creates a new NullPattern (returns singleton).
    */
   static new(): NullPattern {
-    return NullPattern.#instance;
+    return NullPattern._instance;
   }
 
   /**
    * Gets the underlying dcbor-pattern NullPattern.
    */
   get inner(): DCBORNullPattern {
-    return this.#inner;
+    return this._inner;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -61,7 +61,7 @@ export class NullPattern implements Matcher {
     const cbor = haystack.asLeaf();
     if (cbor !== undefined) {
       // Delegate to dcbor-pattern for CBOR matching
-      const dcborPaths = dcborNullPatternPaths(this.#inner, cbor);
+      const dcborPaths = dcborNullPatternPaths(this._inner, cbor);
 
       if (dcborPaths.length > 0) {
         return [[[haystack]], new Map<string, Path[]>()];
@@ -91,7 +91,7 @@ export class NullPattern implements Matcher {
   }
 
   toString(): string {
-    return nullPatternDisplay(this.#inner);
+    return nullPatternDisplay(this._inner);
   }
 
   /**