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

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

@@ -25,10 +25,10 @@ export function registerOrPatternFactory(factory: (pattern: OrPattern) => Patter
  * Corresponds to the Rust `OrPattern` struct in or_pattern.rs
  */
 export class OrPattern 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 OrPattern implements Matcher {
    * Gets the patterns.
    */
   patterns(): Pattern[] {
-    return this.#patterns;
+    return this._patterns;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
-    const anyMatch = this.#patterns.some((pattern) => matchPattern(pattern, haystack));
+    const anyMatch = this._patterns.some((pattern) => matchPattern(pattern, haystack));
 
     const paths = anyMatch ? [[haystack]] : [];
     return [paths, new Map<string, Path[]>()];
@@ -61,7 +61,7 @@ export class OrPattern implements Matcher {
   }
 
   compile(code: Instr[], literals: Pattern[], captures: string[]): void {
-    if (this.#patterns.length === 0) {
+    if (this._patterns.length === 0) {
       return;
     }
 
@@ -69,7 +69,7 @@ export class OrPattern implements Matcher {
     const splits: number[] = [];
 
     // Generate splits for all but the last pattern
-    for (let i = 0; i < this.#patterns.length - 1; i++) {
+    for (let i = 0; i < this._patterns.length - 1; i++) {
       splits.push(code.length);
       code.push({ type: "Split", a: 0, b: 0 }); // Placeholder
     }
@@ -78,11 +78,11 @@ export class OrPattern implements Matcher {
     const jumps: number[] = [];
 
     // Now fill in the actual split targets
-    for (let i = 0; i < this.#patterns.length; i++) {
+    for (let i = 0; i < this._patterns.length; i++) {
       const patternStart = code.length;
 
       // Compile this pattern
-      const pattern = this.#patterns[i];
+      const pattern = this._patterns[i];
       const matcher = pattern as unknown as Matcher;
       matcher.compile(code, literals, captures);
 
@@ -92,7 +92,7 @@ export class OrPattern implements Matcher {
       jumps.push(jumpPastAll);
 
       // If there's a next pattern, update the split to point here
-      if (i < this.#patterns.length - 1) {
+      if (i < this._patterns.length - 1) {
         const nextPattern = code.length;
         code[splits[i]] = { type: "Split", a: patternStart, b: nextPattern };
       }
@@ -109,12 +109,12 @@ export class OrPattern 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(" | ");
   }
@@ -123,11 +123,11 @@ export class OrPattern implements Matcher {
    * Equality comparison.
    */
   equals(other: OrPattern): 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;
       }
     }
@@ -138,6 +138,6 @@ export class OrPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    return this.#patterns.length;
+    return this._patterns.length;
   }
 }

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

@@ -25,10 +25,10 @@ export function registerSearchPatternFactory(factory: (pattern: SearchPattern) =
  * Corresponds to the Rust `SearchPattern` struct in search_pattern.rs
  */
 export class SearchPattern implements Matcher {
-  readonly #pattern: Pattern;
+  private readonly _pattern: Pattern;
 
   private constructor(pattern: Pattern) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -42,15 +42,15 @@ export class SearchPattern implements Matcher {
    * Gets the inner pattern.
    */
   pattern(): Pattern {
-    return this.#pattern;
+    return this._pattern;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
     const resultPaths: Path[] = [];
-    const matcher = this.#pattern as unknown as Matcher;
+    const matcher = this._pattern as unknown as Matcher;
 
     // Walk the envelope tree
-    this.#walkEnvelope(haystack, [], (currentEnvelope, pathToCurrent) => {
+    this._walkEnvelope(haystack, [], (currentEnvelope, pathToCurrent) => {
       // Create the path to this node
       const newPath: Envelope[] = [...pathToCurrent, currentEnvelope];
 
@@ -92,7 +92,7 @@ export class SearchPattern implements Matcher {
   /**
    * Walk the envelope tree recursively.
    */
-  #walkEnvelope(
+  private _walkEnvelope(
     envelope: Envelope,
     pathToCurrent: Envelope[],
     visitor: (envelope: Envelope, path: Envelope[]) => void,
@@ -106,24 +106,24 @@ export class SearchPattern implements Matcher {
 
     // Walk subject if it's different from this envelope
     if (!subject.digest().equals(envelope.digest())) {
-      this.#walkEnvelope(subject, newPath, visitor);
+      this._walkEnvelope(subject, newPath, visitor);
     }
 
     // Walk assertions
     for (const assertion of envelope.assertions()) {
-      this.#walkEnvelope(assertion, newPath, visitor);
+      this._walkEnvelope(assertion, newPath, visitor);
 
       // Walk predicate and object if available
       const predicate = assertion.asPredicate?.();
       if (predicate !== undefined) {
         const assertionPath = [...newPath, assertion];
-        this.#walkEnvelope(predicate, assertionPath, visitor);
+        this._walkEnvelope(predicate, assertionPath, visitor);
       }
 
       const object = assertion.asObject?.();
       if (object !== undefined) {
         const assertionPath = [...newPath, assertion];
-        this.#walkEnvelope(object, assertionPath, visitor);
+        this._walkEnvelope(object, assertionPath, visitor);
       }
     }
 
@@ -131,7 +131,7 @@ export class SearchPattern implements Matcher {
     if (subject.isWrapped()) {
       const unwrapped = subject.tryUnwrap?.();
       if (unwrapped !== undefined) {
-        this.#walkEnvelope(unwrapped, newPath, visitor);
+        this._walkEnvelope(unwrapped, newPath, visitor);
       }
     }
   }
@@ -146,11 +146,11 @@ export class SearchPattern implements Matcher {
 
   compile(code: Instr[], literals: Pattern[], captures: string[]): void {
     const idx = literals.length;
-    literals.push(this.#pattern);
+    literals.push(this._pattern);
 
     // Collect capture names from inner pattern
     const innerNames: string[] = [];
-    collectCaptureNames(this.#pattern, innerNames);
+    collectCaptureNames(this._pattern, innerNames);
 
     const captureMap: [string, number][] = [];
     for (const name of innerNames) {
@@ -170,14 +170,14 @@ export class SearchPattern implements Matcher {
   }
 
   toString(): string {
-    return `search(${(this.#pattern as unknown as { toString(): string }).toString()})`;
+    return `search(${(this._pattern as unknown as { toString(): string }).toString()})`;
   }
 
   /**
    * Equality comparison.
    */
   equals(other: SearchPattern): boolean {
-    return this.#pattern === other.#pattern;
+    return this._pattern === other._pattern;
   }
 
   /**

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

@@ -27,12 +27,12 @@ export function registerTraversePatternFactory(
  * Corresponds to the Rust `TraversePattern` struct in traverse_pattern.rs
  */
 export class TraversePattern implements Matcher {
-  readonly #first: Pattern;
-  readonly #rest: TraversePattern | undefined;
+  private readonly _first: Pattern;
+  private readonly _rest: TraversePattern | undefined;
 
   private constructor(first: Pattern, rest: TraversePattern | undefined) {
-    this.#first = first;
-    this.#rest = rest;
+    this._first = first;
+    this._rest = rest;
   }
 
   /**
@@ -53,19 +53,19 @@ export class TraversePattern implements Matcher {
    * Gets all patterns in this traversal.
    */
   patterns(): Pattern[] {
-    const result: Pattern[] = [this.#first];
-    if (this.#rest !== undefined) {
-      result.push(...this.#rest.patterns());
+    const result: Pattern[] = [this._first];
+    if (this._rest !== undefined) {
+      result.push(...this._rest.patterns());
     }
     return result;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
-    const firstMatcher = this.#first as unknown as Matcher;
+    const firstMatcher = this._first as unknown as Matcher;
     const headPaths = firstMatcher.paths(haystack);
 
     // If there's no further traversal, return head paths
-    if (this.#rest === undefined) {
+    if (this._rest === undefined) {
       return [headPaths, new Map<string, Path[]>()];
     }
 
@@ -74,7 +74,7 @@ export class TraversePattern implements Matcher {
       const lastEnv = path[path.length - 1];
       if (lastEnv !== undefined) {
         // Recursively match the rest of the traversal
-        const tailPaths = this.#rest.paths(lastEnv);
+        const tailPaths = this._rest.paths(lastEnv);
         for (const tailPath of tailPaths) {
           const combined = [...path, ...tailPath];
           result.push(combined);
@@ -95,14 +95,14 @@ export class TraversePattern implements Matcher {
 
   compile(code: Instr[], literals: Pattern[], captures: string[]): void {
     // Compile the first pattern
-    const firstMatcher = this.#first as unknown as Matcher;
+    const firstMatcher = this._first as unknown as Matcher;
     firstMatcher.compile(code, literals, captures);
 
-    if (this.#rest !== undefined) {
+    if (this._rest !== undefined) {
       // Save the current path and switch to last envelope
       code.push({ type: "ExtendTraversal" });
       // Compile the rest of the traversal
-      this.#rest.compile(code, literals, captures);
+      this._rest.compile(code, literals, captures);
       // Combine the paths correctly
       code.push({ type: "CombineTraversal" });
     }
@@ -110,8 +110,8 @@ export class TraversePattern implements Matcher {
 
   isComplex(): boolean {
     // A traversal is complex if `first` is complex, or it has more than one pattern
-    const firstMatcher = this.#first as unknown as Matcher;
-    return firstMatcher.isComplex() || this.#rest !== undefined;
+    const firstMatcher = this._first as unknown as Matcher;
+    return firstMatcher.isComplex() || this._rest !== undefined;
   }
 
   toString(): string {

package/src/pattern/structure/assertions-pattern.ts

@@ -42,10 +42,10 @@ export type AssertionsPatternType =
  * Corresponds to the Rust `AssertionsPattern` enum in assertions_pattern.rs
  */
 export class AssertionsPattern implements Matcher {
-  readonly #pattern: AssertionsPatternType;
+  private readonly _pattern: AssertionsPatternType;
 
   private constructor(pattern: AssertionsPatternType) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -83,18 +83,18 @@ export class AssertionsPattern implements Matcher {
    * Gets the pattern type.
    */
   get patternType(): AssertionsPatternType {
-    return this.#pattern;
+    return this._pattern;
   }
 
   /**
    * Gets the predicate pattern if this has one, undefined otherwise.
    */
   predicatePattern(): Pattern | undefined {
-    if (this.#pattern.type === "WithPredicate") {
-      return this.#pattern.pattern;
+    if (this._pattern.type === "WithPredicate") {
+      return this._pattern.pattern;
     }
-    if (this.#pattern.type === "WithBoth") {
-      return this.#pattern.predicatePattern;
+    if (this._pattern.type === "WithBoth") {
+      return this._pattern.predicatePattern;
     }
     return undefined;
   }
@@ -103,11 +103,11 @@ export class AssertionsPattern implements Matcher {
    * Gets the object pattern if this has one, undefined otherwise.
    */
   objectPattern(): Pattern | undefined {
-    if (this.#pattern.type === "WithObject") {
-      return this.#pattern.pattern;
+    if (this._pattern.type === "WithObject") {
+      return this._pattern.pattern;
     }
-    if (this.#pattern.type === "WithBoth") {
-      return this.#pattern.objectPattern;
+    if (this._pattern.type === "WithBoth") {
+      return this._pattern.objectPattern;
     }
     return undefined;
   }
@@ -116,14 +116,14 @@ export class AssertionsPattern implements Matcher {
     const paths: Path[] = [];
 
     for (const assertion of haystack.assertions()) {
-      switch (this.#pattern.type) {
+      switch (this._pattern.type) {
         case "Any":
           paths.push([assertion]);
           break;
         case "WithPredicate": {
           const predicate = assertion.asPredicate?.();
           if (predicate !== undefined) {
-            const innerMatcher = this.#pattern.pattern as unknown as Matcher;
+            const innerMatcher = this._pattern.pattern as unknown as Matcher;
             if (innerMatcher.matches(predicate)) {
               paths.push([assertion]);
             }
@@ -133,7 +133,7 @@ export class AssertionsPattern implements Matcher {
         case "WithObject": {
           const object = assertion.asObject?.();
           if (object !== undefined) {
-            const innerMatcher = this.#pattern.pattern as unknown as Matcher;
+            const innerMatcher = this._pattern.pattern as unknown as Matcher;
             if (innerMatcher.matches(object)) {
               paths.push([assertion]);
             }
@@ -144,8 +144,8 @@ export class AssertionsPattern implements Matcher {
           const predicate = assertion.asPredicate?.();
           const object = assertion.asObject?.();
           if (predicate !== undefined && object !== undefined) {
-            const predMatcher = this.#pattern.predicatePattern as unknown as Matcher;
-            const objMatcher = this.#pattern.objectPattern as unknown as Matcher;
+            const predMatcher = this._pattern.predicatePattern as unknown as Matcher;
+            const objMatcher = this._pattern.objectPattern as unknown as Matcher;
             if (predMatcher.matches(predicate) && objMatcher.matches(object)) {
               paths.push([assertion]);
             }
@@ -180,15 +180,15 @@ export class AssertionsPattern implements Matcher {
   }
 
   toString(): string {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return "assert";
       case "WithPredicate":
-        return `assertpred(${(this.#pattern.pattern as unknown as { toString(): string }).toString()})`;
+        return `assertpred(${(this._pattern.pattern as unknown as { toString(): string }).toString()})`;
       case "WithObject":
-        return `assertobj(${(this.#pattern.pattern as unknown as { toString(): string }).toString()})`;
+        return `assertobj(${(this._pattern.pattern as unknown as { toString(): string }).toString()})`;
       case "WithBoth":
-        return `assert(${(this.#pattern.predicatePattern as unknown as { toString(): string }).toString()}, ${(this.#pattern.objectPattern as unknown as { toString(): string }).toString()})`;
+        return `assert(${(this._pattern.predicatePattern as unknown as { toString(): string }).toString()}, ${(this._pattern.objectPattern as unknown as { toString(): string }).toString()})`;
     }
   }
 
@@ -196,31 +196,31 @@ export class AssertionsPattern implements Matcher {
    * Equality comparison.
    */
   equals(other: AssertionsPattern): 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 "WithPredicate":
       case "WithObject": {
         const thisPattern = (
-          this.#pattern as { type: "WithPredicate" | "WithObject"; pattern: Pattern }
+          this._pattern as { type: "WithPredicate" | "WithObject"; pattern: Pattern }
         ).pattern;
         const otherPattern = (
-          other.#pattern as { type: "WithPredicate" | "WithObject"; pattern: Pattern }
+          other._pattern as { type: "WithPredicate" | "WithObject"; pattern: Pattern }
         ).pattern;
         return thisPattern === otherPattern;
       }
       case "WithBoth": {
-        const otherBoth = other.#pattern as {
+        const otherBoth = other._pattern as {
           type: "WithBoth";
           predicatePattern: Pattern;
           objectPattern: Pattern;
         };
         return (
-          this.#pattern.predicatePattern === otherBoth.predicatePattern &&
-          this.#pattern.objectPattern === otherBoth.objectPattern
+          this._pattern.predicatePattern === otherBoth.predicatePattern &&
+          this._pattern.objectPattern === otherBoth.objectPattern
         );
       }
     }
@@ -230,7 +230,7 @@ export class AssertionsPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return 0;
       case "WithPredicate":

package/src/pattern/structure/digest-pattern.ts

@@ -49,10 +49,10 @@ export type DigestPatternType =
  * Corresponds to the Rust `DigestPattern` enum in digest_pattern.rs
  */
 export class DigestPattern implements Matcher {
-  readonly #pattern: DigestPatternType;
+  private readonly _pattern: DigestPatternType;
 
   private constructor(pattern: DigestPatternType) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -87,7 +87,7 @@ export class DigestPattern implements Matcher {
    * Gets the pattern type.
    */
   get patternType(): DigestPatternType {
-    return this.#pattern;
+    return this._pattern;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -95,16 +95,16 @@ export class DigestPattern implements Matcher {
     const digestData = digest.data();
     let isHit = false;
 
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         // Any digest matches - every envelope has a digest
         isHit = true;
         break;
       case "Digest":
-        isHit = digest.equals(this.#pattern.digest);
+        isHit = digest.equals(this._pattern.digest);
         break;
       case "Prefix": {
-        const prefix = this.#pattern.prefix;
+        const prefix = this._pattern.prefix;
         if (digestData.length >= prefix.length) {
           isHit = true;
           for (let i = 0; i < prefix.length; i++) {
@@ -118,7 +118,7 @@ export class DigestPattern implements Matcher {
       }
       case "BinaryRegex": {
         const latin1 = bytesToLatin1(digestData);
-        isHit = this.#pattern.regex.test(latin1);
+        isHit = this._pattern.regex.test(latin1);
         break;
       }
     }
@@ -147,15 +147,15 @@ export class DigestPattern implements Matcher {
   }
 
   toString(): string {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return "digest";
       case "Digest":
-        return `digest(${this.#pattern.digest.hex()})`;
+        return `digest(${this._pattern.digest.hex()})`;
       case "Prefix":
-        return `digest(${bytesToHex(this.#pattern.prefix)})`;
+        return `digest(${bytesToHex(this._pattern.prefix)})`;
       case "BinaryRegex":
-        return `digest(/${this.#pattern.regex.source}/)`;
+        return `digest(/${this._pattern.regex.source}/)`;
     }
   }
 
@@ -163,19 +163,19 @@ export class DigestPattern implements Matcher {
    * Equality comparison.
    */
   equals(other: DigestPattern): 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 "Digest":
-        return this.#pattern.digest.equals(
-          (other.#pattern as { type: "Digest"; digest: Digest }).digest,
+        return this._pattern.digest.equals(
+          (other._pattern as { type: "Digest"; digest: Digest }).digest,
         );
       case "Prefix": {
-        const thisPrefix = this.#pattern.prefix;
-        const otherPrefix = (other.#pattern as { type: "Prefix"; prefix: Uint8Array }).prefix;
+        const thisPrefix = this._pattern.prefix;
+        const otherPrefix = (other._pattern as { type: "Prefix"; prefix: Uint8Array }).prefix;
         if (thisPrefix.length !== otherPrefix.length) return false;
         for (let i = 0; i < thisPrefix.length; i++) {
           if (thisPrefix[i] !== otherPrefix[i]) return false;
@@ -184,8 +184,8 @@ export class DigestPattern implements Matcher {
       }
       case "BinaryRegex":
         return (
-          this.#pattern.regex.source ===
-          (other.#pattern as { type: "BinaryRegex"; regex: RegExp }).regex.source
+          this._pattern.regex.source ===
+          (other._pattern as { type: "BinaryRegex"; regex: RegExp }).regex.source
         );
     }
   }
@@ -194,12 +194,12 @@ export class DigestPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return 0;
       case "Digest": {
         // Hash based on first few bytes of digest
-        const data = this.#pattern.digest.data().slice(0, 8);
+        const data = this._pattern.digest.data().slice(0, 8);
         let hash = 0;
         for (const byte of data) {
           hash = (hash * 31 + byte) | 0;
@@ -208,14 +208,14 @@ export class DigestPattern implements Matcher {
       }
       case "Prefix": {
         let hash = 0;
-        for (const byte of this.#pattern.prefix) {
+        for (const byte of this._pattern.prefix) {
           hash = (hash * 31 + byte) | 0;
         }
         return hash;
       }
       case "BinaryRegex": {
         let hash = 0;
-        for (const char of this.#pattern.regex.source) {
+        for (const char of this._pattern.regex.source) {
           hash = (hash * 31 + char.charCodeAt(0)) | 0;
         }
         return hash;