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

package/dist/index.mjs

@@ -262,28 +262,28 @@ function defaultFormatPathsOpts() {
 * Builder for FormatPathsOpts.
 */
 var FormatPathsOptsBuilder = class {
-	#indent = true;
-	#elementFormat = defaultPathElementFormat();
-	#lastElementOnly = false;
+	_indent = true;
+	_elementFormat = defaultPathElementFormat();
+	_lastElementOnly = false;
 	/**
 	* Sets whether to indent each path element.
 	*/
 	indent(indent) {
-		this.#indent = indent;
+		this._indent = indent;
 		return this;
 	}
 	/**
 	* Sets the format for each path element.
 	*/
 	elementFormat(format) {
-		this.#elementFormat = format;
+		this._elementFormat = format;
 		return this;
 	}
 	/**
 	* Sets whether to format only the last element of each path.
 	*/
 	lastElementOnly(lastElementOnly) {
-		this.#lastElementOnly = lastElementOnly;
+		this._lastElementOnly = lastElementOnly;
 		return this;
 	}
 	/**
@@ -291,9 +291,9 @@ var FormatPathsOptsBuilder = class {
 	*/
 	build() {
 		return {
-			indent: this.#indent,
-			elementFormat: this.#elementFormat,
-			lastElementOnly: this.#lastElementOnly
+			indent: this._indent,
+			elementFormat: this._elementFormat,
+			lastElementOnly: this._lastElementOnly
 		};
 	}
 };
@@ -533,9 +533,9 @@ function registerBoolPatternFactory(factory) {
 * Corresponds to the Rust `BoolPattern` struct in bool_pattern.rs
 */
 var BoolPattern = class BoolPattern {
-	#inner;
+	_inner;
 	constructor(inner) {
-		this.#inner = inner;
+		this._inner = inner;
 	}
 	/**
 	* Creates a new BoolPattern that matches any boolean value.
@@ -559,12 +559,12 @@ var BoolPattern = class BoolPattern {
 	* Gets the underlying dcbor-pattern BoolPattern.
 	*/
 	get inner() {
-		return this.#inner;
+		return this._inner;
 	}
 	pathsWithCaptures(haystack) {
-		const cbor$1 = haystack.asLeaf();
-		if (cbor$1 !== void 0) {
-			if (boolPatternPaths(this.#inner, cbor$1).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
+		const cbor = haystack.asLeaf();
+		if (cbor !== void 0) {
+			if (boolPatternPaths(this._inner, cbor).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
 		}
 		return [[], /* @__PURE__ */ new Map()];
 	}
@@ -582,22 +582,22 @@ var BoolPattern = class BoolPattern {
 		return false;
 	}
 	toString() {
-		return boolPatternDisplay(this.#inner);
+		return boolPatternDisplay(this._inner);
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		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 !== other._inner.variant) return false;
+		if (this._inner.variant === "Value" && other._inner.variant === "Value") return this._inner.value === other._inner.value;
 		return true;
 	}
 	/**
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		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;
 	}
 };
@@ -617,27 +617,27 @@ function registerNullPatternFactory(factory) {
 * Corresponds to the Rust `NullPattern` struct in null_pattern.rs
 */
 var NullPattern = class NullPattern {
-	#inner;
-	static #instance = new NullPattern();
+	_inner;
+	static _instance = new NullPattern();
 	constructor() {
-		this.#inner = { variant: "Null" };
+		this._inner = { variant: "Null" };
 	}
 	/**
 	* Creates a new NullPattern (returns singleton).
 	*/
 	static new() {
-		return NullPattern.#instance;
+		return NullPattern._instance;
 	}
 	/**
 	* Gets the underlying dcbor-pattern NullPattern.
 	*/
 	get inner() {
-		return this.#inner;
+		return this._inner;
 	}
 	pathsWithCaptures(haystack) {
-		const cbor$1 = haystack.asLeaf();
-		if (cbor$1 !== void 0) {
-			if (nullPatternPaths(this.#inner, cbor$1).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
+		const cbor = haystack.asLeaf();
+		if (cbor !== void 0) {
+			if (nullPatternPaths(this._inner, cbor).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
 		}
 		return [[], /* @__PURE__ */ new Map()];
 	}
@@ -655,7 +655,7 @@ var NullPattern = class NullPattern {
 		return false;
 	}
 	toString() {
-		return nullPatternDisplay(this.#inner);
+		return nullPatternDisplay(this._inner);
 	}
 	/**
 	* Equality comparison.
@@ -686,9 +686,9 @@ function registerNumberPatternFactory(factory) {
 * Corresponds to the Rust `NumberPattern` struct in number_pattern.rs
 */
 var NumberPattern = class NumberPattern {
-	#inner;
+	_inner;
 	constructor(inner) {
-		this.#inner = inner;
+		this._inner = inner;
 	}
 	/**
 	* Creates a new NumberPattern that matches any number.
@@ -760,12 +760,12 @@ var NumberPattern = class NumberPattern {
 	* Gets the underlying dcbor-pattern NumberPattern.
 	*/
 	get inner() {
-		return this.#inner;
+		return this._inner;
 	}
 	pathsWithCaptures(haystack) {
-		const cbor$1 = haystack.asLeaf();
-		if (cbor$1 !== void 0) {
-			if (numberPatternPaths(this.#inner, cbor$1).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
+		const cbor = haystack.asLeaf();
+		if (cbor !== void 0) {
+			if (numberPatternPaths(this._inner, cbor).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
 		}
 		return [[], /* @__PURE__ */ new Map()];
 	}
@@ -783,14 +783,14 @@ var NumberPattern = class NumberPattern {
 		return false;
 	}
 	toString() {
-		return numberPatternDisplay(this.#inner);
+		return numberPatternDisplay(this._inner);
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		if (this.#inner.variant !== other.#inner.variant) return false;
-		switch (this.#inner.variant) {
+		if (this._inner.variant !== other._inner.variant) return false;
+		switch (this._inner.variant) {
 			case "Any":
 			case "NaN":
 			case "Infinity":
@@ -799,8 +799,8 @@ var NumberPattern = class NumberPattern {
 			case "GreaterThan":
 			case "GreaterThanOrEqual":
 			case "LessThan":
-			case "LessThanOrEqual": return this.#inner.value === other.#inner.value;
-			case "Range": return this.#inner.min === other.#inner.min && this.#inner.max === other.#inner.max;
+			case "LessThanOrEqual": return this._inner.value === other._inner.value;
+			case "Range": return this._inner.min === other._inner.min && this._inner.max === other._inner.max;
 		}
 	}
 	/**
@@ -808,27 +808,27 @@ var NumberPattern = class NumberPattern {
 	*/
 	hashCode() {
 		let hash = 0;
-		switch (this.#inner.variant) {
+		switch (this._inner.variant) {
 			case "Any":
 				hash = 1;
 				break;
 			case "Value":
-				hash = 62 + this.#inner.value;
+				hash = 62 + this._inner.value;
 				break;
 			case "Range":
-				hash = 93 + this.#inner.min + this.#inner.max;
+				hash = 93 + this._inner.min + this._inner.max;
 				break;
 			case "GreaterThan":
-				hash = 124 + this.#inner.value;
+				hash = 124 + this._inner.value;
 				break;
 			case "GreaterThanOrEqual":
-				hash = 155 + this.#inner.value;
+				hash = 155 + this._inner.value;
 				break;
 			case "LessThan":
-				hash = 186 + this.#inner.value;
+				hash = 186 + this._inner.value;
 				break;
 			case "LessThanOrEqual":
-				hash = 217 + this.#inner.value;
+				hash = 217 + this._inner.value;
 				break;
 			case "NaN":
 				hash = 8;
@@ -859,9 +859,9 @@ function registerTextPatternFactory(factory) {
 * Corresponds to the Rust `TextPattern` struct in text_pattern.rs
 */
 var TextPattern = class TextPattern {
-	#inner;
+	_inner;
 	constructor(inner) {
-		this.#inner = inner;
+		this._inner = inner;
 	}
 	/**
 	* Creates a new TextPattern that matches any text.
@@ -891,12 +891,12 @@ var TextPattern = class TextPattern {
 	* Gets the underlying dcbor-pattern TextPattern.
 	*/
 	get inner() {
-		return this.#inner;
+		return this._inner;
 	}
 	pathsWithCaptures(haystack) {
-		const cbor$1 = haystack.asLeaf();
-		if (cbor$1 !== void 0) {
-			if (textPatternPaths(this.#inner, cbor$1).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
+		const cbor = haystack.asLeaf();
+		if (cbor !== void 0) {
+			if (textPatternPaths(this._inner, cbor).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
 		}
 		return [[], /* @__PURE__ */ new Map()];
 	}
@@ -914,17 +914,17 @@ var TextPattern = class TextPattern {
 		return false;
 	}
 	toString() {
-		return textPatternDisplay(this.#inner);
+		return textPatternDisplay(this._inner);
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		if (this.#inner.variant !== other.#inner.variant) return false;
-		switch (this.#inner.variant) {
+		if (this._inner.variant !== other._inner.variant) return false;
+		switch (this._inner.variant) {
 			case "Any": return true;
-			case "Value": return this.#inner.value === other.#inner.value;
-			case "Regex": return this.#inner.pattern.source === other.#inner.pattern.source;
+			case "Value": return this._inner.value === other._inner.value;
+			case "Regex": return this._inner.pattern.source === other._inner.pattern.source;
 		}
 	}
 	/**
@@ -932,17 +932,17 @@ var TextPattern = class TextPattern {
 	*/
 	hashCode() {
 		let hash = 0;
-		switch (this.#inner.variant) {
+		switch (this._inner.variant) {
 			case "Any":
 				hash = 1;
 				break;
 			case "Value": {
-				const val = this.#inner.value;
+				const val = this._inner.value;
 				for (let i = 0; i < val.length; i++) hash = hash * 31 + val.charCodeAt(i);
 				break;
 			}
 			case "Regex":
-				hash = 93 + this.#inner.pattern.source.length;
+				hash = 93 + this._inner.pattern.source.length;
 				break;
 		}
 		return hash;
@@ -964,9 +964,9 @@ function registerByteStringPatternFactory(factory) {
 * Corresponds to the Rust `ByteStringPattern` struct in byte_string_pattern.rs
 */
 var ByteStringPattern = class ByteStringPattern {
-	#inner;
+	_inner;
 	constructor(inner) {
-		this.#inner = inner;
+		this._inner = inner;
 	}
 	/**
 	* Creates a new ByteStringPattern that matches any byte string.
@@ -996,12 +996,12 @@ var ByteStringPattern = class ByteStringPattern {
 	* Gets the underlying dcbor-pattern ByteStringPattern.
 	*/
 	get inner() {
-		return this.#inner;
+		return this._inner;
 	}
 	pathsWithCaptures(haystack) {
-		const cbor$1 = haystack.asLeaf();
-		if (cbor$1 !== void 0) {
-			if (byteStringPatternPaths(this.#inner, cbor$1).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
+		const cbor = haystack.asLeaf();
+		if (cbor !== void 0) {
+			if (byteStringPatternPaths(this._inner, cbor).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
 		}
 		return [[], /* @__PURE__ */ new Map()];
 	}
@@ -1019,23 +1019,23 @@ var ByteStringPattern = class ByteStringPattern {
 		return false;
 	}
 	toString() {
-		return byteStringPatternDisplay(this.#inner);
+		return byteStringPatternDisplay(this._inner);
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		if (this.#inner.variant !== other.#inner.variant) return false;
-		switch (this.#inner.variant) {
+		if (this._inner.variant !== other._inner.variant) return false;
+		switch (this._inner.variant) {
 			case "Any": return true;
 			case "Value": {
-				const a = this.#inner.value;
-				const b = other.#inner.value;
+				const a = this._inner.value;
+				const b = other._inner.value;
 				if (a.length !== b.length) return false;
 				for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
 				return true;
 			}
-			case "BinaryRegex": return this.#inner.pattern.source === other.#inner.pattern.source;
+			case "BinaryRegex": return this._inner.pattern.source === other._inner.pattern.source;
 		}
 	}
 	/**
@@ -1043,17 +1043,17 @@ var ByteStringPattern = class ByteStringPattern {
 	*/
 	hashCode() {
 		let hash = 0;
-		switch (this.#inner.variant) {
+		switch (this._inner.variant) {
 			case "Any":
 				hash = 1;
 				break;
 			case "Value": {
-				const val = this.#inner.value;
+				const val = this._inner.value;
 				for (const byte of val) hash = hash * 31 + byte;
 				break;
 			}
 			case "BinaryRegex":
-				hash = 93 + this.#inner.pattern.source.length;
+				hash = 93 + this._inner.pattern.source.length;
 				break;
 		}
 		return hash;
@@ -1075,9 +1075,9 @@ function registerDatePatternFactory(factory) {
 * Corresponds to the Rust `DatePattern` struct in date_pattern.rs
 */
 var DatePattern = class DatePattern {
-	#inner;
+	_inner;
 	constructor(inner) {
-		this.#inner = inner;
+		this._inner = inner;
 	}
 	/**
 	* Creates a new DatePattern that matches any date.
@@ -1088,8 +1088,8 @@ var DatePattern = class DatePattern {
 	/**
 	* Creates a new DatePattern that matches the specific date.
 	*/
-	static value(date$1) {
-		return new DatePattern(datePatternValue(date$1));
+	static value(date) {
+		return new DatePattern(datePatternValue(date));
 	}
 	/**
 	* Creates a new DatePattern that matches dates within a range (inclusive).
@@ -1100,14 +1100,14 @@ var DatePattern = class DatePattern {
 	/**
 	* Creates a new DatePattern that matches dates on or after the specified date.
 	*/
-	static earliest(date$1) {
-		return new DatePattern(datePatternEarliest(date$1));
+	static earliest(date) {
+		return new DatePattern(datePatternEarliest(date));
 	}
 	/**
 	* Creates a new DatePattern that matches dates on or before the specified date.
 	*/
-	static latest(date$1) {
-		return new DatePattern(datePatternLatest(date$1));
+	static latest(date) {
+		return new DatePattern(datePatternLatest(date));
 	}
 	/**
 	* Creates a new DatePattern that matches dates by their ISO-8601 string representation.
@@ -1132,12 +1132,12 @@ var DatePattern = class DatePattern {
 	* Gets the underlying dcbor-pattern DatePattern.
 	*/
 	get inner() {
-		return this.#inner;
+		return this._inner;
 	}
 	pathsWithCaptures(haystack) {
-		const cbor$1 = haystack.asLeaf();
-		if (cbor$1 !== void 0) {
-			if (datePatternPaths(this.#inner, cbor$1).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
+		const cbor = haystack.asLeaf();
+		if (cbor !== void 0) {
+			if (datePatternPaths(this._inner, cbor).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
 		}
 		return [[], /* @__PURE__ */ new Map()];
 	}
@@ -1155,21 +1155,21 @@ var DatePattern = class DatePattern {
 		return false;
 	}
 	toString() {
-		return datePatternDisplay(this.#inner);
+		return datePatternDisplay(this._inner);
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		if (this.#inner.variant !== other.#inner.variant) return false;
-		return JSON.stringify(this.#inner) === JSON.stringify(other.#inner);
+		if (this._inner.variant !== other._inner.variant) return false;
+		return JSON.stringify(this._inner) === JSON.stringify(other._inner);
 	}
 	/**
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
 		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);
 		return hash;
 	}
@@ -1194,9 +1194,9 @@ function registerArrayPatternFactory(factory) {
 * Corresponds to the Rust `ArrayPattern` struct in array_pattern.rs
 */
 var ArrayPattern = class ArrayPattern {
-	#pattern;
+	_pattern;
 	constructor(pattern) {
-		this.#pattern = pattern;
+		this._pattern = pattern;
 	}
 	/**
 	* Creates a new ArrayPattern that matches any array.
@@ -1244,22 +1244,22 @@ var ArrayPattern = class ArrayPattern {
 	* Gets the pattern type.
 	*/
 	get pattern() {
-		return this.#pattern;
+		return this._pattern;
 	}
 	pathsWithCaptures(haystack) {
-		const cbor$1 = haystack.asLeaf();
-		if (cbor$1 === void 0) return [[], /* @__PURE__ */ new Map()];
-		const array = asCborArray(cbor$1);
+		const cbor = haystack.asLeaf();
+		if (cbor === void 0) return [[], /* @__PURE__ */ new Map()];
+		const array = asCborArray(cbor);
 		if (array === void 0) return [[], /* @__PURE__ */ new Map()];
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return [[[haystack]], /* @__PURE__ */ new Map()];
 			case "Interval": {
 				const length = array.length;
-				if (this.#pattern.interval.contains(length)) return [[[haystack]], /* @__PURE__ */ new Map()];
+				if (this._pattern.interval.contains(length)) return [[[haystack]], /* @__PURE__ */ new Map()];
 				return [[], /* @__PURE__ */ new Map()];
 			}
 			case "DCBORPattern": {
-				const { paths: dcborPaths, captures: dcborCaptures } = patternPathsWithCaptures$1(this.#pattern.pattern, cbor$1);
+				const { paths: dcborPaths, captures: dcborCaptures } = patternPathsWithCaptures$1(this._pattern.pattern, cbor);
 				if (dcborPaths.length > 0) {
 					const envelopePaths = dcborPaths.map((dcborPath) => {
 						const envPath = [haystack];
@@ -1286,7 +1286,7 @@ var ArrayPattern = class ArrayPattern {
 				return [[], /* @__PURE__ */ new Map()];
 			}
 			case "WithPatterns":
-				if (array.length === this.#pattern.patterns.length) return [[[haystack]], /* @__PURE__ */ new Map()];
+				if (array.length === this._pattern.patterns.length) return [[[haystack]], /* @__PURE__ */ new Map()];
 				return [[], /* @__PURE__ */ new Map()];
 		}
 	}
@@ -1304,26 +1304,26 @@ var ArrayPattern = class ArrayPattern {
 		return false;
 	}
 	toString() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return "[*]";
-			case "Interval": return `[{${this.#pattern.interval.toString()}}]`;
-			case "DCBORPattern": return patternDisplay(this.#pattern.pattern);
-			case "WithPatterns": return `[${this.#pattern.patterns.map(String).join(", ")}]`;
+			case "Interval": return `[{${this._pattern.interval.toString()}}]`;
+			case "DCBORPattern": return patternDisplay(this._pattern.pattern);
+			case "WithPatterns": return `[${this._pattern.patterns.map(String).join(", ")}]`;
 		}
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		if (this.#pattern.type !== other.#pattern.type) return false;
-		switch (this.#pattern.type) {
+		if (this._pattern.type !== other._pattern.type) return false;
+		switch (this._pattern.type) {
 			case "Any": return true;
-			case "Interval": return this.#pattern.interval.equals(other.#pattern.interval);
-			case "DCBORPattern": return patternDisplay(this.#pattern.pattern) === patternDisplay(other.#pattern.pattern);
+			case "Interval": return this._pattern.interval.equals(other._pattern.interval);
+			case "DCBORPattern": return patternDisplay(this._pattern.pattern) === patternDisplay(other._pattern.pattern);
 			case "WithPatterns": {
-				const otherPatterns = other.#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;
+				const otherPatterns = other._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;
 				return true;
 			}
 		}
@@ -1332,11 +1332,11 @@ var ArrayPattern = class ArrayPattern {
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return 0;
-			case "Interval": return this.#pattern.interval.min() * 31 + (this.#pattern.interval.max() ?? 0);
-			case "DCBORPattern": return simpleStringHash$3(patternDisplay(this.#pattern.pattern));
-			case "WithPatterns": return this.#pattern.patterns.length;
+			case "Interval": return this._pattern.interval.min() * 31 + (this._pattern.interval.max() ?? 0);
+			case "DCBORPattern": return simpleStringHash$3(patternDisplay(this._pattern.pattern));
+			case "WithPatterns": return this._pattern.patterns.length;
 		}
 	}
 };
@@ -1365,9 +1365,9 @@ function registerMapPatternFactory(factory) {
 * Corresponds to the Rust `MapPattern` struct in map_pattern.rs
 */
 var MapPattern = class MapPattern {
-	#pattern;
+	_pattern;
 	constructor(pattern) {
-		this.#pattern = pattern;
+		this._pattern = pattern;
 	}
 	/**
 	* Creates a new MapPattern that matches any map.
@@ -1388,18 +1388,18 @@ var MapPattern = class MapPattern {
 	* Gets the pattern type.
 	*/
 	get pattern() {
-		return this.#pattern;
+		return this._pattern;
 	}
 	pathsWithCaptures(haystack) {
-		const cbor$1 = haystack.asLeaf();
-		if (cbor$1 === void 0) return [[], /* @__PURE__ */ new Map()];
-		const map$1 = asCborMap(cbor$1);
-		if (map$1 === void 0) return [[], /* @__PURE__ */ new Map()];
-		switch (this.#pattern.type) {
+		const cbor = haystack.asLeaf();
+		if (cbor === void 0) return [[], /* @__PURE__ */ new Map()];
+		const map = asCborMap(cbor);
+		if (map === void 0) return [[], /* @__PURE__ */ new Map()];
+		switch (this._pattern.type) {
 			case "Any": return [[[haystack]], /* @__PURE__ */ new Map()];
 			case "Interval": {
-				const size = map$1.size;
-				if (this.#pattern.interval.contains(size)) return [[[haystack]], /* @__PURE__ */ new Map()];
+				const size = map.size;
+				if (this._pattern.interval.contains(size)) return [[[haystack]], /* @__PURE__ */ new Map()];
 				return [[], /* @__PURE__ */ new Map()];
 			}
 		}
@@ -1418,28 +1418,28 @@ var MapPattern = class MapPattern {
 		return false;
 	}
 	toString() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return "{*}";
-			case "Interval": return `{{${this.#pattern.interval.toString()}}}`;
+			case "Interval": return `{{${this._pattern.interval.toString()}}}`;
 		}
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		if (this.#pattern.type !== other.#pattern.type) return false;
-		switch (this.#pattern.type) {
+		if (this._pattern.type !== other._pattern.type) return false;
+		switch (this._pattern.type) {
 			case "Any": return true;
-			case "Interval": return this.#pattern.interval.equals(other.#pattern.interval);
+			case "Interval": return this._pattern.interval.equals(other._pattern.interval);
 		}
 	}
 	/**
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return 0;
-			case "Interval": return this.#pattern.interval.min() * 31 + (this.#pattern.interval.max() ?? 0);
+			case "Interval": return this._pattern.interval.min() * 31 + (this._pattern.interval.max() ?? 0);
 		}
 	}
 };
@@ -1459,9 +1459,9 @@ function registerKnownValuePatternFactory(factory) {
 * Corresponds to the Rust `KnownValuePattern` struct in known_value_pattern.rs
 */
 var KnownValuePattern = class KnownValuePattern {
-	#inner;
+	_inner;
 	constructor(inner) {
-		this.#inner = inner;
+		this._inner = inner;
 	}
 	/**
 	* Creates a new KnownValuePattern that matches any known value.
@@ -1497,17 +1497,17 @@ var KnownValuePattern = class KnownValuePattern {
 	* Gets the underlying dcbor-pattern KnownValuePattern.
 	*/
 	get inner() {
-		return this.#inner;
+		return this._inner;
 	}
 	pathsWithCaptures(haystack) {
 		const envCase = haystack.case();
 		if (envCase.type === "knownValue") {
 			const knownValueCbor = envCase.value.taggedCbor();
-			if (knownValuePatternMatches(this.#inner, knownValueCbor)) return [[[haystack]], /* @__PURE__ */ new Map()];
+			if (knownValuePatternMatches(this._inner, knownValueCbor)) return [[[haystack]], /* @__PURE__ */ new Map()];
 		}
-		const leafCbor$1 = haystack.asLeaf();
-		if (leafCbor$1 !== void 0) {
-			if (knownValuePatternMatches(this.#inner, leafCbor$1)) return [[[haystack]], /* @__PURE__ */ new Map()];
+		const leafCbor = haystack.asLeaf();
+		if (leafCbor !== void 0) {
+			if (knownValuePatternMatches(this._inner, leafCbor)) return [[[haystack]], /* @__PURE__ */ new Map()];
 		}
 		return [[], /* @__PURE__ */ new Map()];
 	}
@@ -1525,29 +1525,29 @@ var KnownValuePattern = class KnownValuePattern {
 		return false;
 	}
 	toString() {
-		return knownValuePatternDisplay(this.#inner);
+		return knownValuePatternDisplay(this._inner);
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		if (this.#inner.variant !== other.#inner.variant) return false;
-		switch (this.#inner.variant) {
+		if (this._inner.variant !== other._inner.variant) return false;
+		switch (this._inner.variant) {
 			case "Any": return true;
-			case "Value": return this.#inner.value.valueBigInt() === other.#inner.value.valueBigInt();
-			case "Named": return this.#inner.name === other.#inner.name;
-			case "Regex": return this.#inner.pattern.source === other.#inner.pattern.source;
+			case "Value": return this._inner.value.valueBigInt() === other._inner.value.valueBigInt();
+			case "Named": return this._inner.name === other._inner.name;
+			case "Regex": return this._inner.pattern.source === other._inner.pattern.source;
 		}
 	}
 	/**
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		switch (this.#inner.variant) {
+		switch (this._inner.variant) {
 			case "Any": return 0;
-			case "Value": return Number(this.#inner.value.valueBigInt() & BigInt(4294967295));
-			case "Named": return simpleStringHash$2(this.#inner.name);
-			case "Regex": return simpleStringHash$2(this.#inner.pattern.source);
+			case "Value": return Number(this._inner.value.valueBigInt() & BigInt(4294967295));
+			case "Named": return simpleStringHash$2(this._inner.name);
+			case "Regex": return simpleStringHash$2(this._inner.pattern.source);
 		}
 	}
 };
@@ -1586,9 +1586,9 @@ function registerTaggedPatternFactory(factory) {
 * Corresponds to the Rust `TaggedPattern` struct in tagged_pattern.rs
 */
 var TaggedPattern = class TaggedPattern {
-	#inner;
+	_inner;
 	constructor(inner) {
-		this.#inner = inner;
+		this._inner = inner;
 	}
 	/**
 	* Creates a new TaggedPattern that matches any tagged value.
@@ -1624,12 +1624,12 @@ var TaggedPattern = class TaggedPattern {
 	* Gets the underlying dcbor-pattern TaggedPattern.
 	*/
 	get inner() {
-		return this.#inner;
+		return this._inner;
 	}
 	pathsWithCaptures(haystack) {
-		const cbor$1 = haystack.subject().asLeaf();
-		if (cbor$1 !== void 0) {
-			const [dcborPaths, dcborCaptures] = taggedPatternPathsWithCaptures(this.#inner, cbor$1);
+		const cbor = haystack.subject().asLeaf();
+		if (cbor !== void 0) {
+			const [dcborPaths, dcborCaptures] = taggedPatternPathsWithCaptures(this._inner, cbor);
 			if (dcborPaths.length > 0) {
 				const envelopePaths = dcborPaths.map((dcborPath) => {
 					const envPath = [haystack];
@@ -1670,26 +1670,26 @@ var TaggedPattern = class TaggedPattern {
 		return false;
 	}
 	toString() {
-		return taggedPatternDisplay(this.#inner, patternDisplay);
+		return taggedPatternDisplay(this._inner, patternDisplay);
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		if (this.#inner.variant !== other.#inner.variant) return false;
-		switch (this.#inner.variant) {
+		if (this._inner.variant !== other._inner.variant) return false;
+		switch (this._inner.variant) {
 			case "Any": return true;
 			case "Tag": {
-				const otherTag = other.#inner;
-				return this.#inner.tag.value === otherTag.tag.value && patternDisplay(this.#inner.pattern) === patternDisplay(otherTag.pattern);
+				const otherTag = other._inner;
+				return this._inner.tag.value === otherTag.tag.value && patternDisplay(this._inner.pattern) === patternDisplay(otherTag.pattern);
 			}
 			case "Name": {
-				const otherName = other.#inner;
-				return this.#inner.name === otherName.name && patternDisplay(this.#inner.pattern) === patternDisplay(otherName.pattern);
+				const otherName = other._inner;
+				return this._inner.name === otherName.name && patternDisplay(this._inner.pattern) === patternDisplay(otherName.pattern);
 			}
 			case "Regex": {
-				const otherRegex = other.#inner;
-				return this.#inner.regex.source === otherRegex.regex.source && patternDisplay(this.#inner.pattern) === patternDisplay(otherRegex.pattern);
+				const otherRegex = other._inner;
+				return this._inner.regex.source === otherRegex.regex.source && patternDisplay(this._inner.pattern) === patternDisplay(otherRegex.pattern);
 			}
 		}
 	}
@@ -1697,11 +1697,11 @@ var TaggedPattern = class TaggedPattern {
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		switch (this.#inner.variant) {
+		switch (this._inner.variant) {
 			case "Any": return 0;
-			case "Tag": return Number(BigInt(this.#inner.tag.value) & BigInt(4294967295));
-			case "Name": return simpleStringHash$1(this.#inner.name);
-			case "Regex": return simpleStringHash$1(this.#inner.regex.source);
+			case "Tag": return Number(BigInt(this._inner.tag.value) & BigInt(4294967295));
+			case "Name": return simpleStringHash$1(this._inner.name);
+			case "Regex": return simpleStringHash$1(this._inner.regex.source);
 		}
 	}
 };
@@ -1737,9 +1737,9 @@ function registerCBORPatternFactory(factory) {
 * Corresponds to the Rust `CBORPattern` enum in cbor_pattern.rs
 */
 var CBORPattern = class CBORPattern {
-	#pattern;
+	_pattern;
 	constructor(pattern) {
-		this.#pattern = pattern;
+		this._pattern = pattern;
 	}
 	/**
 	* Creates a new CBORPattern that matches any CBOR value.
@@ -1778,15 +1778,15 @@ var CBORPattern = class CBORPattern {
 	* Gets the pattern type.
 	*/
 	get pattern() {
-		return this.#pattern;
+		return this._pattern;
 	}
 	/**
 	* Convert dcbor captures to envelope captures.
 	*/
-	#convertDcborCapturesToEnvelopeCaptures(dcborCaptures, baseEnvelope, baseCbor) {
+	_convertDcborCapturesToEnvelopeCaptures(dcborCaptures, baseEnvelope, baseCbor) {
 		const envelopeCaptures = /* @__PURE__ */ new Map();
 		for (const [captureName, dcborCapturePaths] of dcborCaptures) {
-			const envelopeCapturePaths = dcborCapturePaths.map((dcborPath) => this.#convertDcborPathToEnvelopePath(dcborPath, baseEnvelope, baseCbor));
+			const envelopeCapturePaths = dcborCapturePaths.map((dcborPath) => this._convertDcborPathToEnvelopePath(dcborPath, baseEnvelope, baseCbor));
 			envelopeCaptures.set(captureName, envelopeCapturePaths);
 		}
 		return envelopeCaptures;
@@ -1794,7 +1794,7 @@ var CBORPattern = class CBORPattern {
 	/**
 	* Convert a single dcbor path to an envelope path.
 	*/
-	#convertDcborPathToEnvelopePath(dcborPath, baseEnvelope, baseCbor) {
+	_convertDcborPathToEnvelopePath(dcborPath, baseEnvelope, baseCbor) {
 		const envelopePath = [baseEnvelope];
 		const elementsToAdd = dcborPath.length > 0 && dcborPath[0]?.toDiagnostic() === baseCbor.toDiagnostic() ? dcborPath.slice(1) : dcborPath;
 		for (const cborElement of elementsToAdd) envelopePath.push(Envelope.newLeaf(cborElement));
@@ -1803,7 +1803,7 @@ var CBORPattern = class CBORPattern {
 	/**
 	* Collect capture names from a dcbor pattern.
 	*/
-	#collectDcborCaptureNames(dcborPattern, names) {
+	_collectDcborCaptureNames(dcborPattern, names) {
 		const patternStr = patternDisplay(dcborPattern);
 		let i = 0;
 		while (i < patternStr.length) if (patternStr[i] === "@") {
@@ -1820,13 +1820,13 @@ var CBORPattern = class CBORPattern {
 		const envCase = haystack.case();
 		if (envCase.type === "knownValue") {
 			const knownValueCbor = envCase.value.taggedCbor();
-			switch (this.#pattern.type) {
+			switch (this._pattern.type) {
 				case "Any": return [[[haystack]], /* @__PURE__ */ new Map()];
 				case "Value":
-					if (knownValueCbor.toDiagnostic() === this.#pattern.cbor.toDiagnostic()) return [[[haystack]], /* @__PURE__ */ new Map()];
+					if (knownValueCbor.toDiagnostic() === this._pattern.cbor.toDiagnostic()) return [[[haystack]], /* @__PURE__ */ new Map()];
 					return [[], /* @__PURE__ */ new Map()];
 				case "Pattern": {
-					const { paths: dcborPaths, captures: dcborCaptures } = patternPathsWithCaptures$1(this.#pattern.pattern, knownValueCbor);
+					const { paths: dcborPaths, captures: dcborCaptures } = patternPathsWithCaptures$1(this._pattern.pattern, knownValueCbor);
 					if (dcborPaths.length > 0) {
 						const basePath = [haystack];
 						return [dcborPaths.map((dcborPath) => {
@@ -1836,29 +1836,29 @@ var CBORPattern = class CBORPattern {
 								if (elem !== void 0) extendedPath.push(Envelope.newLeaf(elem));
 							}
 							return extendedPath;
-						}), this.#convertDcborCapturesToEnvelopeCaptures(dcborCaptures, haystack, knownValueCbor)];
+						}), this._convertDcborCapturesToEnvelopeCaptures(dcborCaptures, haystack, knownValueCbor)];
 					}
 					return [[], /* @__PURE__ */ new Map()];
 				}
 			}
 		}
-		const leafCbor$1 = haystack.asLeaf();
-		if (leafCbor$1 === void 0) return [[], /* @__PURE__ */ new Map()];
-		switch (this.#pattern.type) {
+		const leafCbor = haystack.asLeaf();
+		if (leafCbor === void 0) return [[], /* @__PURE__ */ new Map()];
+		switch (this._pattern.type) {
 			case "Any": return [[[haystack]], /* @__PURE__ */ new Map()];
 			case "Value":
-				if (leafCbor$1.toDiagnostic() === this.#pattern.cbor.toDiagnostic()) return [[[haystack]], /* @__PURE__ */ new Map()];
+				if (leafCbor.toDiagnostic() === this._pattern.cbor.toDiagnostic()) return [[[haystack]], /* @__PURE__ */ new Map()];
 				return [[], /* @__PURE__ */ new Map()];
 			case "Pattern": {
-				const { paths: dcborPaths, captures: dcborCaptures } = patternPathsWithCaptures$1(this.#pattern.pattern, leafCbor$1);
+				const { paths: dcborPaths, captures: dcborCaptures } = patternPathsWithCaptures$1(this._pattern.pattern, leafCbor);
 				if (dcborPaths.length > 0) {
 					const basePath = [haystack];
 					return [dcborPaths.map((dcborPath) => {
 						const extendedPath = [...basePath];
-						const elementsToAdd = dcborPath.length > 0 && dcborPath[0]?.toDiagnostic() === leafCbor$1.toDiagnostic() ? dcborPath.slice(1) : dcborPath;
+						const elementsToAdd = dcborPath.length > 0 && dcborPath[0]?.toDiagnostic() === leafCbor.toDiagnostic() ? dcborPath.slice(1) : dcborPath;
 						for (const cborElement of elementsToAdd) extendedPath.push(Envelope.newLeaf(cborElement));
 						return extendedPath;
-					}), this.#convertDcborCapturesToEnvelopeCaptures(dcborCaptures, haystack, leafCbor$1)];
+					}), this._convertDcborCapturesToEnvelopeCaptures(dcborCaptures, haystack, leafCbor)];
 				}
 				return [[], /* @__PURE__ */ new Map()];
 			}
@@ -1871,9 +1871,9 @@ var CBORPattern = class CBORPattern {
 		return this.paths(haystack).length > 0;
 	}
 	compile(code, literals, captures) {
-		if (this.#pattern.type === "Pattern") {
+		if (this._pattern.type === "Pattern") {
 			const captureNames = [];
-			this.#collectDcborCaptureNames(this.#pattern.pattern, captureNames);
+			this._collectDcborCaptureNames(this._pattern.pattern, captureNames);
 			for (const name of captureNames) if (!captures.includes(name)) captures.push(name);
 		}
 		if (createLeafCBORPattern === void 0) throw new Error("CBORPattern factory not registered");
@@ -1883,31 +1883,31 @@ var CBORPattern = class CBORPattern {
 		return false;
 	}
 	toString() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return "cbor";
-			case "Value": return `cbor(${this.#pattern.cbor.toDiagnostic()})`;
-			case "Pattern": return `cbor(/${patternDisplay(this.#pattern.pattern)}/)`;
+			case "Value": return `cbor(${this._pattern.cbor.toDiagnostic()})`;
+			case "Pattern": return `cbor(/${patternDisplay(this._pattern.pattern)}/)`;
 		}
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		if (this.#pattern.type !== other.#pattern.type) return false;
-		switch (this.#pattern.type) {
+		if (this._pattern.type !== other._pattern.type) return false;
+		switch (this._pattern.type) {
 			case "Any": return true;
-			case "Value": return this.#pattern.cbor.toDiagnostic() === other.#pattern.cbor.toDiagnostic();
-			case "Pattern": return patternDisplay(this.#pattern.pattern) === patternDisplay(other.#pattern.pattern);
+			case "Value": return this._pattern.cbor.toDiagnostic() === other._pattern.cbor.toDiagnostic();
+			case "Pattern": return patternDisplay(this._pattern.pattern) === patternDisplay(other._pattern.pattern);
 		}
 	}
 	/**
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return 0;
-			case "Value": return simpleStringHash(this.#pattern.cbor.toDiagnostic());
-			case "Pattern": return simpleStringHash(patternDisplay(this.#pattern.pattern));
+			case "Value": return simpleStringHash(this._pattern.cbor.toDiagnostic());
+			case "Pattern": return simpleStringHash(patternDisplay(this._pattern.pattern));
 		}
 	}
 };
@@ -2190,9 +2190,9 @@ function registerSubjectPatternFactory(factory) {
 * Corresponds to the Rust `SubjectPattern` enum in subject_pattern.rs
 */
 var SubjectPattern = class SubjectPattern {
-	#pattern;
+	_pattern;
 	constructor(pattern) {
-		this.#pattern = pattern;
+		this._pattern = pattern;
 	}
 	/**
 	* Creates a new SubjectPattern that matches any subject.
@@ -2213,23 +2213,23 @@ var SubjectPattern = class SubjectPattern {
 	* Gets the pattern type.
 	*/
 	get patternType() {
-		return this.#pattern;
+		return this._pattern;
 	}
 	/**
 	* Gets the inner pattern if this is a Pattern type, undefined otherwise.
 	*/
 	innerPattern() {
-		return this.#pattern.type === "Pattern" ? this.#pattern.pattern : void 0;
+		return this._pattern.type === "Pattern" ? this._pattern.pattern : void 0;
 	}
 	pathsWithCaptures(haystack) {
-		const subject$1 = haystack.subject();
+		const subject = haystack.subject();
 		let paths;
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any":
-				paths = [[subject$1]];
+				paths = [[subject]];
 				break;
 			case "Pattern":
-				if (this.#pattern.pattern.matches(subject$1)) paths = [[subject$1]];
+				if (this._pattern.pattern.matches(subject)) paths = [[subject]];
 				else paths = [];
 				break;
 		}
@@ -2242,14 +2242,14 @@ var SubjectPattern = class SubjectPattern {
 		return this.paths(haystack).length > 0;
 	}
 	compile(code, literals, captures) {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any":
 				code.push({ type: "NavigateSubject" });
 				break;
 			case "Pattern":
 				code.push({ type: "NavigateSubject" });
 				code.push({ type: "ExtendTraversal" });
-				this.#pattern.pattern.compile(code, literals, captures);
+				this._pattern.pattern.compile(code, literals, captures);
 				code.push({ type: "CombineTraversal" });
 				break;
 		}
@@ -2258,24 +2258,24 @@ var SubjectPattern = class SubjectPattern {
 		return false;
 	}
 	toString() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return "subj";
-			case "Pattern": return `subj(${this.#pattern.pattern.toString()})`;
+			case "Pattern": return `subj(${this._pattern.pattern.toString()})`;
 		}
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		if (this.#pattern.type !== other.#pattern.type) return false;
-		if (this.#pattern.type === "Any") return true;
-		return this.#pattern.pattern === other.#pattern.pattern;
+		if (this._pattern.type !== other._pattern.type) return false;
+		if (this._pattern.type === "Any") return true;
+		return this._pattern.pattern === other._pattern.pattern;
 	}
 	/**
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		return this.#pattern.type === "Any" ? 0 : 1;
+		return this._pattern.type === "Any" ? 0 : 1;
 	}
 };
 
@@ -2291,9 +2291,9 @@ function registerPredicatePatternFactory(factory) {
 * Corresponds to the Rust `PredicatePattern` enum in predicate_pattern.rs
 */
 var PredicatePattern = class PredicatePattern {
-	#pattern;
+	_pattern;
 	constructor(pattern) {
-		this.#pattern = pattern;
+		this._pattern = pattern;
 	}
 	/**
 	* Creates a new PredicatePattern that matches any predicate.
@@ -2314,24 +2314,24 @@ var PredicatePattern = class PredicatePattern {
 	* Gets the pattern type.
 	*/
 	get patternType() {
-		return this.#pattern;
+		return this._pattern;
 	}
 	/**
 	* Gets the inner pattern if this is a Pattern type, undefined otherwise.
 	*/
 	innerPattern() {
-		return this.#pattern.type === "Pattern" ? this.#pattern.pattern : void 0;
+		return this._pattern.type === "Pattern" ? this._pattern.pattern : void 0;
 	}
 	pathsWithCaptures(haystack) {
-		const predicate$1 = haystack.asPredicate?.();
-		if (predicate$1 === void 0) return [[], /* @__PURE__ */ new Map()];
+		const predicate = haystack.asPredicate?.();
+		if (predicate === void 0) return [[], /* @__PURE__ */ new Map()];
 		let paths;
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any":
-				paths = [[predicate$1]];
+				paths = [[predicate]];
 				break;
 			case "Pattern":
-				if (this.#pattern.pattern.matches(predicate$1)) paths = [[predicate$1]];
+				if (this._pattern.pattern.matches(predicate)) paths = [[predicate]];
 				else paths = [];
 				break;
 		}
@@ -2356,24 +2356,24 @@ var PredicatePattern = class PredicatePattern {
 		return false;
 	}
 	toString() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return "pred";
-			case "Pattern": return `pred(${this.#pattern.pattern.toString()})`;
+			case "Pattern": return `pred(${this._pattern.pattern.toString()})`;
 		}
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		if (this.#pattern.type !== other.#pattern.type) return false;
-		if (this.#pattern.type === "Any") return true;
-		return this.#pattern.pattern === other.#pattern.pattern;
+		if (this._pattern.type !== other._pattern.type) return false;
+		if (this._pattern.type === "Any") return true;
+		return this._pattern.pattern === other._pattern.pattern;
 	}
 	/**
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		return this.#pattern.type === "Any" ? 0 : 1;
+		return this._pattern.type === "Any" ? 0 : 1;
 	}
 };
 
@@ -2389,9 +2389,9 @@ function registerObjectPatternFactory(factory) {
 * Corresponds to the Rust `ObjectPattern` enum in object_pattern.rs
 */
 var ObjectPattern = class ObjectPattern {
-	#pattern;
+	_pattern;
 	constructor(pattern) {
-		this.#pattern = pattern;
+		this._pattern = pattern;
 	}
 	/**
 	* Creates a new ObjectPattern that matches any object.
@@ -2412,24 +2412,24 @@ var ObjectPattern = class ObjectPattern {
 	* Gets the pattern type.
 	*/
 	get patternType() {
-		return this.#pattern;
+		return this._pattern;
 	}
 	/**
 	* Gets the inner pattern if this is a Pattern type, undefined otherwise.
 	*/
 	innerPattern() {
-		return this.#pattern.type === "Pattern" ? this.#pattern.pattern : void 0;
+		return this._pattern.type === "Pattern" ? this._pattern.pattern : void 0;
 	}
 	pathsWithCaptures(haystack) {
-		const object$1 = haystack.asObject?.();
-		if (object$1 === void 0) return [[], /* @__PURE__ */ new Map()];
+		const object = haystack.asObject?.();
+		if (object === void 0) return [[], /* @__PURE__ */ new Map()];
 		let paths;
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any":
-				paths = [[object$1]];
+				paths = [[object]];
 				break;
 			case "Pattern":
-				if (this.#pattern.pattern.matches(object$1)) paths = [[object$1]];
+				if (this._pattern.pattern.matches(object)) paths = [[object]];
 				else paths = [];
 				break;
 		}
@@ -2454,24 +2454,24 @@ var ObjectPattern = class ObjectPattern {
 		return false;
 	}
 	toString() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return "obj";
-			case "Pattern": return `obj(${this.#pattern.pattern.toString()})`;
+			case "Pattern": return `obj(${this._pattern.pattern.toString()})`;
 		}
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		if (this.#pattern.type !== other.#pattern.type) return false;
-		if (this.#pattern.type === "Any") return true;
-		return this.#pattern.pattern === other.#pattern.pattern;
+		if (this._pattern.type !== other._pattern.type) return false;
+		if (this._pattern.type === "Any") return true;
+		return this._pattern.pattern === other._pattern.pattern;
 	}
 	/**
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		return this.#pattern.type === "Any" ? 0 : 1;
+		return this._pattern.type === "Any" ? 0 : 1;
 	}
 };
 
@@ -2487,9 +2487,9 @@ function registerAssertionsPatternFactory(factory) {
 * Corresponds to the Rust `AssertionsPattern` enum in assertions_pattern.rs
 */
 var AssertionsPattern = class AssertionsPattern {
-	#pattern;
+	_pattern;
 	constructor(pattern) {
-		this.#pattern = pattern;
+		this._pattern = pattern;
 	}
 	/**
 	* Creates a new AssertionsPattern that matches any assertion.
@@ -2532,49 +2532,49 @@ var AssertionsPattern = class AssertionsPattern {
 	* Gets the pattern type.
 	*/
 	get patternType() {
-		return this.#pattern;
+		return this._pattern;
 	}
 	/**
 	* Gets the predicate pattern if this has one, undefined otherwise.
 	*/
 	predicatePattern() {
-		if (this.#pattern.type === "WithPredicate") return this.#pattern.pattern;
-		if (this.#pattern.type === "WithBoth") return this.#pattern.predicatePattern;
+		if (this._pattern.type === "WithPredicate") return this._pattern.pattern;
+		if (this._pattern.type === "WithBoth") return this._pattern.predicatePattern;
 	}
 	/**
 	* Gets the object pattern if this has one, undefined otherwise.
 	*/
 	objectPattern() {
-		if (this.#pattern.type === "WithObject") return this.#pattern.pattern;
-		if (this.#pattern.type === "WithBoth") return this.#pattern.objectPattern;
+		if (this._pattern.type === "WithObject") return this._pattern.pattern;
+		if (this._pattern.type === "WithBoth") return this._pattern.objectPattern;
 	}
 	pathsWithCaptures(haystack) {
 		const paths = [];
-		for (const assertion of haystack.assertions()) switch (this.#pattern.type) {
+		for (const assertion of haystack.assertions()) switch (this._pattern.type) {
 			case "Any":
 				paths.push([assertion]);
 				break;
 			case "WithPredicate": {
-				const predicate$1 = assertion.asPredicate?.();
-				if (predicate$1 !== void 0) {
-					if (this.#pattern.pattern.matches(predicate$1)) paths.push([assertion]);
+				const predicate = assertion.asPredicate?.();
+				if (predicate !== void 0) {
+					if (this._pattern.pattern.matches(predicate)) paths.push([assertion]);
 				}
 				break;
 			}
 			case "WithObject": {
-				const object$1 = assertion.asObject?.();
-				if (object$1 !== void 0) {
-					if (this.#pattern.pattern.matches(object$1)) paths.push([assertion]);
+				const object = assertion.asObject?.();
+				if (object !== void 0) {
+					if (this._pattern.pattern.matches(object)) paths.push([assertion]);
 				}
 				break;
 			}
 			case "WithBoth": {
-				const predicate$1 = assertion.asPredicate?.();
-				const object$1 = assertion.asObject?.();
-				if (predicate$1 !== void 0 && object$1 !== void 0) {
-					const predMatcher = this.#pattern.predicatePattern;
-					const objMatcher = this.#pattern.objectPattern;
-					if (predMatcher.matches(predicate$1) && objMatcher.matches(object$1)) paths.push([assertion]);
+				const predicate = assertion.asPredicate?.();
+				const object = assertion.asObject?.();
+				if (predicate !== void 0 && object !== void 0) {
+					const predMatcher = this._pattern.predicatePattern;
+					const objMatcher = this._pattern.objectPattern;
+					if (predMatcher.matches(predicate) && objMatcher.matches(object)) paths.push([assertion]);
 				}
 				break;
 			}
@@ -2600,25 +2600,25 @@ var AssertionsPattern = class AssertionsPattern {
 		return false;
 	}
 	toString() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return "assert";
-			case "WithPredicate": return `assertpred(${this.#pattern.pattern.toString()})`;
-			case "WithObject": return `assertobj(${this.#pattern.pattern.toString()})`;
-			case "WithBoth": return `assert(${this.#pattern.predicatePattern.toString()}, ${this.#pattern.objectPattern.toString()})`;
+			case "WithPredicate": return `assertpred(${this._pattern.pattern.toString()})`;
+			case "WithObject": return `assertobj(${this._pattern.pattern.toString()})`;
+			case "WithBoth": return `assert(${this._pattern.predicatePattern.toString()}, ${this._pattern.objectPattern.toString()})`;
 		}
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		if (this.#pattern.type !== other.#pattern.type) return false;
-		switch (this.#pattern.type) {
+		if (this._pattern.type !== other._pattern.type) return false;
+		switch (this._pattern.type) {
 			case "Any": return true;
 			case "WithPredicate":
-			case "WithObject": return this.#pattern.pattern === other.#pattern.pattern;
+			case "WithObject": return this._pattern.pattern === other._pattern.pattern;
 			case "WithBoth": {
-				const otherBoth = other.#pattern;
-				return this.#pattern.predicatePattern === otherBoth.predicatePattern && this.#pattern.objectPattern === otherBoth.objectPattern;
+				const otherBoth = other._pattern;
+				return this._pattern.predicatePattern === otherBoth.predicatePattern && this._pattern.objectPattern === otherBoth.objectPattern;
 			}
 		}
 	}
@@ -2626,7 +2626,7 @@ var AssertionsPattern = class AssertionsPattern {
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return 0;
 			case "WithPredicate": return 1;
 			case "WithObject": return 2;
@@ -2655,9 +2655,9 @@ function bytesToLatin1(bytes) {
 * Corresponds to the Rust `DigestPattern` enum in digest_pattern.rs
 */
 var DigestPattern = class DigestPattern {
-	#pattern;
+	_pattern;
 	constructor(pattern) {
-		this.#pattern = pattern;
+		this._pattern = pattern;
 	}
 	/**
 	* Creates a new DigestPattern that matches any digest.
@@ -2668,10 +2668,10 @@ var DigestPattern = class DigestPattern {
 	/**
 	* Creates a new DigestPattern that matches the exact digest.
 	*/
-	static digest(digest$1) {
+	static digest(digest) {
 		return new DigestPattern({
 			type: "Digest",
-			digest: digest$1
+			digest
 		});
 	}
 	/**
@@ -2696,21 +2696,21 @@ var DigestPattern = class DigestPattern {
 	* Gets the pattern type.
 	*/
 	get patternType() {
-		return this.#pattern;
+		return this._pattern;
 	}
 	pathsWithCaptures(haystack) {
-		const digest$1 = haystack.digest();
-		const digestData = digest$1.data();
+		const digest = haystack.digest();
+		const digestData = digest.data();
 		let isHit = false;
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any":
 				isHit = true;
 				break;
 			case "Digest":
-				isHit = digest$1.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++) if (digestData[i] !== prefix[i]) {
@@ -2722,7 +2722,7 @@ var DigestPattern = class DigestPattern {
 			}
 			case "BinaryRegex": {
 				const latin1 = bytesToLatin1(digestData);
-				isHit = this.#pattern.regex.test(latin1);
+				isHit = this._pattern.regex.test(latin1);
 				break;
 			}
 		}
@@ -2742,51 +2742,51 @@ var DigestPattern = class DigestPattern {
 		return false;
 	}
 	toString() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return "digest";
-			case "Digest": return `digest(${this.#pattern.digest.hex()})`;
-			case "Prefix": return `digest(${bytesToHex(this.#pattern.prefix)})`;
-			case "BinaryRegex": return `digest(/${this.#pattern.regex.source}/)`;
+			case "Digest": return `digest(${this._pattern.digest.hex()})`;
+			case "Prefix": return `digest(${bytesToHex(this._pattern.prefix)})`;
+			case "BinaryRegex": return `digest(/${this._pattern.regex.source}/)`;
 		}
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		if (this.#pattern.type !== other.#pattern.type) return false;
-		switch (this.#pattern.type) {
+		if (this._pattern.type !== other._pattern.type) return false;
+		switch (this._pattern.type) {
 			case "Any": return true;
-			case "Digest": return this.#pattern.digest.equals(other.#pattern.digest);
+			case "Digest": return this._pattern.digest.equals(other._pattern.digest);
 			case "Prefix": {
-				const thisPrefix = this.#pattern.prefix;
-				const otherPrefix = other.#pattern.prefix;
+				const thisPrefix = this._pattern.prefix;
+				const otherPrefix = other._pattern.prefix;
 				if (thisPrefix.length !== otherPrefix.length) return false;
 				for (let i = 0; i < thisPrefix.length; i++) if (thisPrefix[i] !== otherPrefix[i]) return false;
 				return true;
 			}
-			case "BinaryRegex": return this.#pattern.regex.source === other.#pattern.regex.source;
+			case "BinaryRegex": return this._pattern.regex.source === other._pattern.regex.source;
 		}
 	}
 	/**
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return 0;
 			case "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;
 				return hash;
 			}
 			case "Prefix": {
 				let hash = 0;
-				for (const byte of this.#pattern.prefix) hash = hash * 31 + byte | 0;
+				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) hash = hash * 31 + char.charCodeAt(0) | 0;
+				for (const char of this._pattern.regex.source) hash = hash * 31 + char.charCodeAt(0) | 0;
 				return hash;
 			}
 		}
@@ -2805,9 +2805,9 @@ function registerNodePatternFactory(factory) {
 * Corresponds to the Rust `NodePattern` enum in node_pattern.rs
 */
 var NodePattern = class NodePattern {
-	#pattern;
+	_pattern;
 	constructor(pattern) {
-		this.#pattern = pattern;
+		this._pattern = pattern;
 	}
 	/**
 	* Creates a new NodePattern that matches any node.
@@ -2846,13 +2846,13 @@ var NodePattern = class NodePattern {
 	* Gets the pattern type.
 	*/
 	get patternType() {
-		return this.#pattern;
+		return this._pattern;
 	}
 	/**
 	* Gets the subject pattern if this is a WithSubject type, undefined otherwise.
 	*/
 	subjectPattern() {
-		return this.#pattern.type === "WithSubject" ? this.#pattern.subjectPattern : void 0;
+		return this._pattern.type === "WithSubject" ? this._pattern.subjectPattern : void 0;
 	}
 	/**
 	* Gets the assertion patterns (empty array if none).
@@ -2863,12 +2863,12 @@ var NodePattern = class NodePattern {
 	pathsWithCaptures(haystack) {
 		if (!haystack.isNode()) return [[], /* @__PURE__ */ new Map()];
 		let isHit = false;
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any":
 				isHit = true;
 				break;
 			case "AssertionsInterval":
-				isHit = this.#pattern.interval.contains(haystack.assertions().length);
+				isHit = this._pattern.interval.contains(haystack.assertions().length);
 				break;
 			case "WithSubject":
 				isHit = true;
@@ -2890,30 +2890,30 @@ var NodePattern = class NodePattern {
 		return false;
 	}
 	toString() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return "node";
-			case "AssertionsInterval": return `node(${this.#pattern.interval.toString()})`;
-			case "WithSubject": return `node(${this.#pattern.subjectPattern.toString()})`;
+			case "AssertionsInterval": return `node(${this._pattern.interval.toString()})`;
+			case "WithSubject": return `node(${this._pattern.subjectPattern.toString()})`;
 		}
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		if (this.#pattern.type !== other.#pattern.type) return false;
-		switch (this.#pattern.type) {
+		if (this._pattern.type !== other._pattern.type) return false;
+		switch (this._pattern.type) {
 			case "Any": return true;
-			case "AssertionsInterval": return this.#pattern.interval.equals(other.#pattern.interval);
-			case "WithSubject": return this.#pattern.subjectPattern === other.#pattern.subjectPattern;
+			case "AssertionsInterval": return this._pattern.interval.equals(other._pattern.interval);
+			case "WithSubject": return this._pattern.subjectPattern === other._pattern.subjectPattern;
 		}
 	}
 	/**
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return 0;
-			case "AssertionsInterval": return this.#pattern.interval.min() * 31 + (this.#pattern.interval.max() ?? 0);
+			case "AssertionsInterval": return this._pattern.interval.min() * 31 + (this._pattern.interval.max() ?? 0);
 			case "WithSubject": return 1;
 		}
 	}
@@ -2931,9 +2931,9 @@ function registerObscuredPatternFactory(factory) {
 * Corresponds to the Rust `ObscuredPattern` enum in obscured_pattern.rs
 */
 var ObscuredPattern = class ObscuredPattern {
-	#pattern;
+	_pattern;
 	constructor(pattern) {
-		this.#pattern = pattern;
+		this._pattern = pattern;
 	}
 	/**
 	* Creates a new ObscuredPattern that matches any obscured element.
@@ -2963,11 +2963,11 @@ var ObscuredPattern = class ObscuredPattern {
 	* Gets the pattern type.
 	*/
 	get patternType() {
-		return this.#pattern;
+		return this._pattern;
 	}
 	pathsWithCaptures(haystack) {
 		let isHit = false;
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any":
 				isHit = haystack.isObscured();
 				break;
@@ -2997,7 +2997,7 @@ var ObscuredPattern = class ObscuredPattern {
 		return false;
 	}
 	toString() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return "obscured";
 			case "Elided": return "elided";
 			case "Encrypted": return "encrypted";
@@ -3008,13 +3008,13 @@ var ObscuredPattern = class ObscuredPattern {
 	* Equality comparison.
 	*/
 	equals(other) {
-		return this.#pattern.type === other.#pattern.type;
+		return this._pattern.type === other._pattern.type;
 	}
 	/**
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return 0;
 			case "Elided": return 1;
 			case "Encrypted": return 2;
@@ -3035,9 +3035,9 @@ function registerWrappedPatternFactory(factory) {
 * Corresponds to the Rust `WrappedPattern` enum in wrapped_pattern.rs
 */
 var WrappedPattern = class WrappedPattern {
-	#pattern;
+	_pattern;
 	constructor(pattern) {
-		this.#pattern = pattern;
+		this._pattern = pattern;
 	}
 	/**
 	* Creates a new WrappedPattern that matches any wrapped envelope without descending.
@@ -3066,25 +3066,25 @@ var WrappedPattern = class WrappedPattern {
 	* Gets the pattern type.
 	*/
 	get patternType() {
-		return this.#pattern;
+		return this._pattern;
 	}
 	/**
 	* Gets the inner pattern if this is an Unwrap type, undefined otherwise.
 	*/
 	innerPattern() {
-		return this.#pattern.type === "Unwrap" ? this.#pattern.pattern : void 0;
+		return this._pattern.type === "Unwrap" ? this._pattern.pattern : void 0;
 	}
 	pathsWithCaptures(haystack) {
-		const subject$1 = haystack.subject();
-		if (!subject$1.isWrapped()) return [[], /* @__PURE__ */ new Map()];
+		const subject = haystack.subject();
+		if (!subject.isWrapped()) return [[], /* @__PURE__ */ new Map()];
 		let paths;
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any":
 				paths = [[haystack]];
 				break;
 			case "Unwrap": {
-				const unwrapped = subject$1.tryUnwrap?.();
-				if (unwrapped !== void 0) paths = this.#pattern.pattern.paths(unwrapped).map((path) => {
+				const unwrapped = subject.tryUnwrap?.();
+				if (unwrapped !== void 0) paths = this._pattern.pattern.paths(unwrapped).map((path) => {
 					return [haystack, ...path];
 				});
 				else paths = [];
@@ -3101,7 +3101,7 @@ var WrappedPattern = class WrappedPattern {
 	}
 	compile(code, literals, captures) {
 		if (createStructureWrappedPattern === void 0) throw new Error("WrappedPattern factory not registered");
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": {
 				const idx = literals.length;
 				literals.push(createStructureWrappedPattern(this));
@@ -3122,7 +3122,7 @@ var WrappedPattern = class WrappedPattern {
 					type: "PushAxis",
 					axis: "Wrapped"
 				});
-				this.#pattern.pattern.compile(code, literals, captures);
+				this._pattern.pattern.compile(code, literals, captures);
 				break;
 			}
 		}
@@ -3131,10 +3131,10 @@ var WrappedPattern = class WrappedPattern {
 		return false;
 	}
 	toString() {
-		switch (this.#pattern.type) {
+		switch (this._pattern.type) {
 			case "Any": return "wrapped";
 			case "Unwrap": {
-				const patternStr = this.#pattern.pattern.toString();
+				const patternStr = this._pattern.pattern.toString();
 				if (patternStr === "*") return "unwrap";
 				return `unwrap(${patternStr})`;
 			}
@@ -3144,15 +3144,15 @@ var WrappedPattern = class WrappedPattern {
 	* Equality comparison.
 	*/
 	equals(other) {
-		if (this.#pattern.type !== other.#pattern.type) return false;
-		if (this.#pattern.type === "Any") return true;
-		return this.#pattern.pattern === other.#pattern.pattern;
+		if (this._pattern.type !== other._pattern.type) return false;
+		if (this._pattern.type === "Any") return true;
+		return this._pattern.pattern === other._pattern.pattern;
 	}
 	/**
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		return this.#pattern.type === "Any" ? 0 : 1;
+		return this._pattern.type === "Any" ? 0 : 1;
 	}
 };
 
@@ -3392,9 +3392,9 @@ function registerAndPatternFactory(factory) {
 * Corresponds to the Rust `AndPattern` struct in and_pattern.rs
 */
 var AndPattern = class AndPattern {
-	#patterns;
+	_patterns;
 	constructor(patterns) {
-		this.#patterns = patterns;
+		this._patterns = patterns;
 	}
 	/**
 	* Creates a new AndPattern with the given patterns.
@@ -3406,10 +3406,10 @@ var AndPattern = class AndPattern {
 	* Gets the patterns.
 	*/
 	patterns() {
-		return this.#patterns;
+		return this._patterns;
 	}
 	pathsWithCaptures(haystack) {
-		return [this.#patterns.every((pattern) => matchPattern(pattern, haystack)) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
+		return [this._patterns.every((pattern) => matchPattern(pattern, haystack)) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
 	}
 	paths(haystack) {
 		return this.pathsWithCaptures(haystack)[0];
@@ -3418,27 +3418,27 @@ var AndPattern = class AndPattern {
 		return this.paths(haystack).length > 0;
 	}
 	compile(code, literals, captures) {
-		for (const pattern of this.#patterns) pattern.compile(code, literals, captures);
+		for (const pattern of this._patterns) pattern.compile(code, literals, captures);
 	}
 	isComplex() {
-		return this.#patterns.length > 1 || this.#patterns.some((p) => p.isComplex());
+		return this._patterns.length > 1 || this._patterns.some((p) => p.isComplex());
 	}
 	toString() {
-		return this.#patterns.map((p) => p.toString()).join(" & ");
+		return this._patterns.map((p) => p.toString()).join(" & ");
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		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]) return false;
+		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]) return false;
 		return true;
 	}
 	/**
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		return this.#patterns.length;
+		return this._patterns.length;
 	}
 };
 
@@ -3454,9 +3454,9 @@ function registerOrPatternFactory(factory) {
 * Corresponds to the Rust `OrPattern` struct in or_pattern.rs
 */
 var OrPattern = class OrPattern {
-	#patterns;
+	_patterns;
 	constructor(patterns) {
-		this.#patterns = patterns;
+		this._patterns = patterns;
 	}
 	/**
 	* Creates a new OrPattern with the given patterns.
@@ -3468,10 +3468,10 @@ var OrPattern = class OrPattern {
 	* Gets the patterns.
 	*/
 	patterns() {
-		return this.#patterns;
+		return this._patterns;
 	}
 	pathsWithCaptures(haystack) {
-		return [this.#patterns.some((pattern) => matchPattern(pattern, haystack)) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
+		return [this._patterns.some((pattern) => matchPattern(pattern, haystack)) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
 	}
 	paths(haystack) {
 		return this.pathsWithCaptures(haystack)[0];
@@ -3480,9 +3480,9 @@ var OrPattern = class OrPattern {
 		return this.paths(haystack).length > 0;
 	}
 	compile(code, literals, captures) {
-		if (this.#patterns.length === 0) return;
+		if (this._patterns.length === 0) return;
 		const splits = [];
-		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",
@@ -3491,16 +3491,16 @@ var OrPattern = class OrPattern {
 			});
 		}
 		const jumps = [];
-		for (let i = 0; i < this.#patterns.length; i++) {
+		for (let i = 0; i < this._patterns.length; i++) {
 			const patternStart = code.length;
-			this.#patterns[i].compile(code, literals, captures);
+			this._patterns[i].compile(code, literals, captures);
 			const jumpPastAll = code.length;
 			code.push({
 				type: "Jump",
 				address: 0
 			});
 			jumps.push(jumpPastAll);
-			if (i < this.#patterns.length - 1) {
+			if (i < this._patterns.length - 1) {
 				const nextPattern = code.length;
 				code[splits[i]] = {
 					type: "Split",
@@ -3516,24 +3516,24 @@ var OrPattern = class OrPattern {
 		};
 	}
 	isComplex() {
-		return this.#patterns.length > 1 || this.#patterns.some((p) => p.isComplex());
+		return this._patterns.length > 1 || this._patterns.some((p) => p.isComplex());
 	}
 	toString() {
-		return this.#patterns.map((p) => p.toString()).join(" | ");
+		return this._patterns.map((p) => p.toString()).join(" | ");
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		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]) return false;
+		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]) return false;
 		return true;
 	}
 	/**
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		return this.#patterns.length;
+		return this._patterns.length;
 	}
 };
 
@@ -3549,9 +3549,9 @@ function registerNotPatternFactory(factory) {
 * Corresponds to the Rust `NotPattern` struct in not_pattern.rs
 */
 var NotPattern = class NotPattern {
-	#pattern;
+	_pattern;
 	constructor(pattern) {
-		this.#pattern = pattern;
+		this._pattern = pattern;
 	}
 	/**
 	* Creates a new NotPattern with the given pattern.
@@ -3563,10 +3563,10 @@ var NotPattern = class NotPattern {
 	* Gets the inner pattern.
 	*/
 	pattern() {
-		return this.#pattern;
+		return this._pattern;
 	}
 	pathsWithCaptures(haystack) {
-		return [!matchPattern(this.#pattern, haystack) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
+		return [!matchPattern(this._pattern, haystack) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
 	}
 	paths(haystack) {
 		return this.pathsWithCaptures(haystack)[0];
@@ -3576,7 +3576,7 @@ var NotPattern = class NotPattern {
 	}
 	compile(code, literals, _captures) {
 		const idx = literals.length;
-		literals.push(this.#pattern);
+		literals.push(this._pattern);
 		code.push({
 			type: "NotMatch",
 			patternIndex: idx
@@ -3586,13 +3586,13 @@ var NotPattern = class NotPattern {
 		return false;
 	}
 	toString() {
-		return `!${this.#pattern.toString()}`;
+		return `!${this._pattern.toString()}`;
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		return this.#pattern === other.#pattern;
+		return this._pattern === other._pattern;
 	}
 	/**
 	* Hash code for use in Maps/Sets.
@@ -3614,11 +3614,11 @@ function registerCapturePatternFactory(factory) {
 * Corresponds to the Rust `CapturePattern` struct in capture_pattern.rs
 */
 var CapturePattern = class CapturePattern {
-	#name;
-	#pattern;
+	_name;
+	_pattern;
 	constructor(name, pattern) {
-		this.#name = name;
-		this.#pattern = pattern;
+		this._name = name;
+		this._pattern = pattern;
 	}
 	/**
 	* Creates a new CapturePattern with the given name and pattern.
@@ -3630,19 +3630,19 @@ var CapturePattern = class CapturePattern {
 	* Gets the name of the capture.
 	*/
 	name() {
-		return this.#name;
+		return this._name;
 	}
 	/**
 	* Gets the inner pattern.
 	*/
 	pattern() {
-		return this.#pattern;
+		return this._pattern;
 	}
 	pathsWithCaptures(haystack) {
-		const [paths, caps] = this.#pattern.pathsWithCaptures(haystack);
+		const [paths, caps] = this._pattern.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];
 	}
@@ -3654,12 +3654,12 @@ var CapturePattern = class CapturePattern {
 	}
 	compile(code, literals, captures) {
 		const id = captures.length;
-		captures.push(this.#name);
+		captures.push(this._name);
 		code.push({
 			type: "CaptureStart",
 			captureIndex: id
 		});
-		this.#pattern.compile(code, literals, captures);
+		this._pattern.compile(code, literals, captures);
 		code.push({
 			type: "CaptureEnd",
 			captureIndex: id
@@ -3669,20 +3669,20 @@ var CapturePattern = class CapturePattern {
 		return false;
 	}
 	toString() {
-		return `@${this.#name}(${this.#pattern.toString()})`;
+		return `@${this._name}(${this._pattern.toString()})`;
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		return this.#name === other.#name && this.#pattern === other.#pattern;
+		return this._name === other._name && this._pattern === other._pattern;
 	}
 	/**
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
 		let hash = 0;
-		for (const char of this.#name) hash = hash * 31 + char.charCodeAt(0) | 0;
+		for (const char of this._name) hash = hash * 31 + char.charCodeAt(0) | 0;
 		return hash;
 	}
 };
@@ -3699,9 +3699,9 @@ function registerSearchPatternFactory(factory) {
 * Corresponds to the Rust `SearchPattern` struct in search_pattern.rs
 */
 var SearchPattern = class SearchPattern {
-	#pattern;
+	_pattern;
 	constructor(pattern) {
-		this.#pattern = pattern;
+		this._pattern = pattern;
 	}
 	/**
 	* Creates a new SearchPattern with the given pattern.
@@ -3713,15 +3713,15 @@ var SearchPattern = class SearchPattern {
 	* Gets the inner pattern.
 	*/
 	pattern() {
-		return this.#pattern;
+		return this._pattern;
 	}
 	pathsWithCaptures(haystack) {
 		const resultPaths = [];
-		const matcher = this.#pattern;
-		this.#walkEnvelope(haystack, [], (currentEnvelope, pathToCurrent) => {
+		const matcher = this._pattern;
+		this._walkEnvelope(haystack, [], (currentEnvelope, pathToCurrent) => {
 			const newPath = [...pathToCurrent, currentEnvelope];
-			const patternPaths$1 = matcher.paths(currentEnvelope);
-			for (const patternPath of patternPaths$1) {
+			const patternPaths = matcher.paths(currentEnvelope);
+			for (const patternPath of patternPaths) {
 				const fullPath = [...newPath];
 				if (patternPath.length > 1) fullPath.push(...patternPath.slice(1));
 				else if (patternPath.length === 1) {
@@ -3745,27 +3745,27 @@ var SearchPattern = class SearchPattern {
 	/**
 	* Walk the envelope tree recursively.
 	*/
-	#walkEnvelope(envelope, pathToCurrent, visitor) {
+	_walkEnvelope(envelope, pathToCurrent, visitor) {
 		visitor(envelope, pathToCurrent);
-		const subject$1 = envelope.subject();
+		const subject = envelope.subject();
 		const newPath = [...pathToCurrent, envelope];
-		if (!subject$1.digest().equals(envelope.digest())) this.#walkEnvelope(subject$1, newPath, visitor);
+		if (!subject.digest().equals(envelope.digest())) this._walkEnvelope(subject, newPath, visitor);
 		for (const assertion of envelope.assertions()) {
-			this.#walkEnvelope(assertion, newPath, visitor);
-			const predicate$1 = assertion.asPredicate?.();
-			if (predicate$1 !== void 0) {
+			this._walkEnvelope(assertion, newPath, visitor);
+			const predicate = assertion.asPredicate?.();
+			if (predicate !== void 0) {
 				const assertionPath = [...newPath, assertion];
-				this.#walkEnvelope(predicate$1, assertionPath, visitor);
+				this._walkEnvelope(predicate, assertionPath, visitor);
 			}
-			const object$1 = assertion.asObject?.();
-			if (object$1 !== void 0) {
+			const object = assertion.asObject?.();
+			if (object !== void 0) {
 				const assertionPath = [...newPath, assertion];
-				this.#walkEnvelope(object$1, assertionPath, visitor);
+				this._walkEnvelope(object, assertionPath, visitor);
 			}
 		}
-		if (subject$1.isWrapped()) {
-			const unwrapped = subject$1.tryUnwrap?.();
-			if (unwrapped !== void 0) this.#walkEnvelope(unwrapped, newPath, visitor);
+		if (subject.isWrapped()) {
+			const unwrapped = subject.tryUnwrap?.();
+			if (unwrapped !== void 0) this._walkEnvelope(unwrapped, newPath, visitor);
 		}
 	}
 	paths(haystack) {
@@ -3776,9 +3776,9 @@ var SearchPattern = class SearchPattern {
 	}
 	compile(code, literals, captures) {
 		const idx = literals.length;
-		literals.push(this.#pattern);
+		literals.push(this._pattern);
 		const innerNames = [];
-		collectCaptureNames$1(this.#pattern, innerNames);
+		collectCaptureNames$1(this._pattern, innerNames);
 		const captureMap = [];
 		for (const name of innerNames) {
 			let pos = captures.indexOf(name);
@@ -3798,13 +3798,13 @@ var SearchPattern = class SearchPattern {
 		return true;
 	}
 	toString() {
-		return `search(${this.#pattern.toString()})`;
+		return `search(${this._pattern.toString()})`;
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		return this.#pattern === other.#pattern;
+		return this._pattern === other._pattern;
 	}
 	/**
 	* Hash code for use in Maps/Sets.
@@ -3833,11 +3833,11 @@ function registerTraversePatternFactory(factory) {
 * Corresponds to the Rust `TraversePattern` struct in traverse_pattern.rs
 */
 var TraversePattern = class TraversePattern {
-	#first;
-	#rest;
+	_first;
+	_rest;
 	constructor(first, rest) {
-		this.#first = first;
-		this.#rest = rest;
+		this._first = first;
+		this._rest = rest;
 	}
 	/**
 	* Creates a new TraversePattern with the given patterns.
@@ -3852,18 +3852,18 @@ var TraversePattern = class TraversePattern {
 	* Gets all patterns in this traversal.
 	*/
 	patterns() {
-		const result = [this.#first];
-		if (this.#rest !== void 0) result.push(...this.#rest.patterns());
+		const result = [this._first];
+		if (this._rest !== void 0) result.push(...this._rest.patterns());
 		return result;
 	}
 	pathsWithCaptures(haystack) {
-		const headPaths = this.#first.paths(haystack);
-		if (this.#rest === void 0) return [headPaths, /* @__PURE__ */ new Map()];
+		const headPaths = this._first.paths(haystack);
+		if (this._rest === void 0) return [headPaths, /* @__PURE__ */ new Map()];
 		const result = [];
 		for (const path of headPaths) {
 			const lastEnv = path[path.length - 1];
 			if (lastEnv !== void 0) {
-				const tailPaths = this.#rest.paths(lastEnv);
+				const tailPaths = this._rest.paths(lastEnv);
 				for (const tailPath of tailPaths) {
 					const combined = [...path, ...tailPath];
 					result.push(combined);
@@ -3879,15 +3879,15 @@ var TraversePattern = class TraversePattern {
 		return this.paths(haystack).length > 0;
 	}
 	compile(code, literals, captures) {
-		this.#first.compile(code, literals, captures);
-		if (this.#rest !== void 0) {
+		this._first.compile(code, literals, captures);
+		if (this._rest !== void 0) {
 			code.push({ type: "ExtendTraversal" });
-			this.#rest.compile(code, literals, captures);
+			this._rest.compile(code, literals, captures);
 			code.push({ type: "CombineTraversal" });
 		}
 	}
 	isComplex() {
-		return this.#first.isComplex() || this.#rest !== void 0;
+		return this._first.isComplex() || this._rest !== void 0;
 	}
 	toString() {
 		return this.patterns().map((p) => p.toString()).join(" -> ");
@@ -3922,11 +3922,11 @@ function registerGroupPatternFactory(factory) {
 * Corresponds to the Rust `GroupPattern` struct in repeat_pattern.rs
 */
 var GroupPattern = class GroupPattern {
-	#pattern;
-	#quantifier;
+	_pattern;
+	_quantifier;
 	constructor(pattern, quantifier) {
-		this.#pattern = pattern;
-		this.#quantifier = quantifier;
+		this._pattern = pattern;
+		this._quantifier = quantifier;
 	}
 	/**
 	* Creates a new GroupPattern with the specified sub-pattern and quantifier.
@@ -3944,13 +3944,13 @@ var GroupPattern = class GroupPattern {
 	* Gets the sub-pattern of this group pattern.
 	*/
 	pattern() {
-		return this.#pattern;
+		return this._pattern;
 	}
 	/**
 	* Gets the quantifier of this group pattern.
 	*/
 	quantifier() {
-		return this.#quantifier;
+		return this._quantifier;
 	}
 	pathsWithCaptures(_haystack) {
 		throw new Error("GroupPattern does not support pathsWithCaptures directly; use compile instead");
@@ -3959,35 +3959,35 @@ var GroupPattern = class GroupPattern {
 		return this.pathsWithCaptures(haystack)[0];
 	}
 	matches(haystack) {
-		return this.#pattern.matches(haystack);
+		return this._pattern.matches(haystack);
 	}
 	compile(code, literals, _captures) {
 		const idx = literals.length;
-		literals.push(this.#pattern);
+		literals.push(this._pattern);
 		code.push({
 			type: "Repeat",
 			patternIndex: idx,
-			quantifier: this.#quantifier
+			quantifier: this._quantifier
 		});
 	}
 	isComplex() {
 		return true;
 	}
 	toString() {
-		const formattedRange = this.#quantifier.toString();
-		return `(${this.#pattern.toString()})${formattedRange}`;
+		const formattedRange = this._quantifier.toString();
+		return `(${this._pattern.toString()})${formattedRange}`;
 	}
 	/**
 	* Equality comparison.
 	*/
 	equals(other) {
-		return this.#pattern === other.#pattern && this.#quantifier.equals(other.#quantifier);
+		return this._pattern === other._pattern && this._quantifier.equals(other._quantifier);
 	}
 	/**
 	* Hash code for use in Maps/Sets.
 	*/
 	hashCode() {
-		return this.#quantifier.min() * 31 + (this.#quantifier.max() ?? 0);
+		return this._quantifier.min() * 31 + (this._quantifier.max() ?? 0);
 	}
 };
 
@@ -4214,9 +4214,9 @@ function axisChildren(axis, env) {
 			return [];
 		case "Wrapped":
 			if (envCase.type === "node") {
-				const subject$1 = envCase.subject;
-				if (subject$1.isWrapped()) {
-					const unwrapped = subject$1.unwrap();
+				const subject = envCase.subject;
+				if (subject.isWrapped()) {
+					const unwrapped = subject.unwrap();
 					if (unwrapped !== void 0) return [[unwrapped, "Content"]];
 				}
 			} else if (envCase.type === "wrapped") return [[envCase.envelope, "Content"]];
@@ -4512,9 +4512,9 @@ function runThread(prog, start, out) {
 				}
 				case "NavigateSubject":
 					if (th.env.isNode()) {
-						const subject$1 = th.env.subject();
-						th.env = subject$1;
-						th.path.push(subject$1);
+						const subject = th.env.subject();
+						th.env = subject;
+						th.path.push(subject);
 					}
 					th.pc += 1;
 					continue;
@@ -4588,12 +4588,12 @@ function run(prog, root) {
 		seen: /* @__PURE__ */ new Set()
 	}, out);
 	return out.map(([path, caps]) => {
-		const map$1 = /* @__PURE__ */ new Map();
+		const map = /* @__PURE__ */ new Map();
 		for (let i = 0; i < caps.length; i++) {
 			const paths = caps[i];
-			if (paths.length > 0) map$1.set(prog.captureNames[i], paths);
+			if (paths.length > 0) map.set(prog.captureNames[i], paths);
 		}
-		return [path, map$1];
+		return [path, map];
 	});
 }
 /**
@@ -4965,10 +4965,10 @@ function convertMetaPatternToEnvelopePattern(metaPattern, originalPattern) {
 /**
 * Creates a Leaf pattern.
 */
-function patternLeaf(leaf$1) {
+function patternLeaf(leaf) {
 	return {
 		type: "Leaf",
-		pattern: leaf$1
+		pattern: leaf
 	};
 }
 /**
@@ -5501,26 +5501,26 @@ function isHexDigit(ch) {
 * Lexer for Gordian Envelope pattern syntax.
 */
 var Lexer = class {
-	#source;
-	#position = 0;
-	#tokenStart = 0;
-	#peekedToken = void 0;
+	_source;
+	_position = 0;
+	_tokenStart = 0;
+	_peekedToken = void 0;
 	constructor(source) {
-		this.#source = source;
+		this._source = source;
 	}
 	/**
 	* Gets the current position in the source.
 	*/
 	get position() {
-		return this.#position;
+		return this._position;
 	}
 	/**
 	* Peeks at the next token without consuming it.
 	*/
 	peekToken() {
-		if (this.#peekedToken !== void 0) return this.#peekedToken;
+		if (this._peekedToken !== void 0) return this._peekedToken;
 		const result = this.next();
-		this.#peekedToken = result;
+		this._peekedToken = result;
 		return result;
 	}
 	/**
@@ -5528,50 +5528,50 @@ var Lexer = class {
 	*/
 	span() {
 		return {
-			start: this.#tokenStart,
-			end: this.#position
+			start: this._tokenStart,
+			end: this._position
 		};
 	}
 	/**
 	* Gets the remaining source string.
 	*/
 	remainder() {
-		return this.#source.slice(this.#position);
+		return this._source.slice(this._position);
 	}
 	/**
 	* Peeks at the current character without consuming it.
 	*/
 	peek() {
-		if (this.#position >= this.#source.length) return;
-		return this.#source[this.#position];
+		if (this._position >= this._source.length) return;
+		return this._source[this._position];
 	}
 	/**
 	* Peeks at the next character without consuming current.
 	*/
 	peekNext() {
-		if (this.#position + 1 >= this.#source.length) return;
-		return this.#source[this.#position + 1];
+		if (this._position + 1 >= this._source.length) return;
+		return this._source[this._position + 1];
 	}
 	/**
 	* Advances the position by n characters.
 	*/
 	bump(n = 1) {
-		this.#position = Math.min(this.#position + n, this.#source.length);
+		this._position = Math.min(this._position + n, this._source.length);
 	}
 	/**
 	* Skips whitespace.
 	*/
-	#skipWhitespace() {
-		while (this.#position < this.#source.length) {
-			const ch = this.#source[this.#position];
-			if (ch !== void 0 && isWhitespace(ch)) this.#position++;
+	_skipWhitespace() {
+		while (this._position < this._source.length) {
+			const ch = this._source[this._position];
+			if (ch !== void 0 && isWhitespace(ch)) this._position++;
 			else break;
 		}
 	}
 	/**
 	* Parses a string literal (after the opening quote).
 	*/
-	#parseStringLiteral() {
+	_parseStringLiteral() {
 		const src = this.remainder();
 		let escape = false;
 		let content = "";
@@ -5615,7 +5615,7 @@ var Lexer = class {
 	/**
 	* Parses a regex pattern (after the opening slash).
 	*/
-	#parseRegex() {
+	_parseRegex() {
 		const src = this.remainder();
 		let escape = false;
 		for (let i = 0; i < src.length; i++) {
@@ -5642,7 +5642,7 @@ var Lexer = class {
 	/**
 	* Parses a hex pattern (after h').
 	*/
-	#parseHexPattern() {
+	_parseHexPattern() {
 		const src = this.remainder();
 		for (let i = 0; i < src.length; i++) {
 			const ch = src[i];
@@ -5666,7 +5666,7 @@ var Lexer = class {
 	/**
 	* Parses a hex binary regex (after h'/).
 	*/
-	#parseHexBinaryRegex() {
+	_parseHexBinaryRegex() {
 		const src = this.remainder();
 		let escape = false;
 		for (let i = 0; i < src.length; i++) {
@@ -5694,7 +5694,7 @@ var Lexer = class {
 	/**
 	* Parses a date pattern (after date').
 	*/
-	#parseDatePattern() {
+	_parseDatePattern() {
 		const src = this.remainder();
 		for (let i = 0; i < src.length; i++) if (src[i] === "'") {
 			const content = src.slice(0, i);
@@ -5706,7 +5706,7 @@ var Lexer = class {
 	/**
 	* Parses a range pattern (after {).
 	*/
-	#parseRange() {
+	_parseRange() {
 		const src = this.remainder();
 		let pos = 0;
 		while (pos < src.length && src[pos] !== void 0 && isWhitespace(src[pos])) pos++;
@@ -5755,7 +5755,7 @@ var Lexer = class {
 	/**
 	* Parses a single quoted pattern (after ').
 	*/
-	#parseSingleQuotedPattern() {
+	_parseSingleQuotedPattern() {
 		const src = this.remainder();
 		for (let i = 0; i < src.length; i++) if (src[i] === "'") {
 			const content = src.slice(0, i);
@@ -5767,7 +5767,7 @@ var Lexer = class {
 	/**
 	* Parses a single quoted regex (after '/).
 	*/
-	#parseSingleQuotedRegex() {
+	_parseSingleQuotedRegex() {
 		const src = this.remainder();
 		let escape = false;
 		for (let i = 0; i < src.length; i++) {
@@ -5795,8 +5795,8 @@ var Lexer = class {
 	/**
 	* Parses a number (integer or float).
 	*/
-	#parseNumber() {
-		const startPos = this.#position;
+	_parseNumber() {
+		const startPos = this._position;
 		let isFloat = false;
 		let isNegative = false;
 		if (this.peek() === "-") {
@@ -5828,16 +5828,16 @@ var Lexer = class {
 				c = this.peek();
 			}
 		}
-		const numStr = this.#source.slice(startPos, this.#position);
+		const numStr = this._source.slice(startPos, this._position);
 		if (isFloat) {
-			const value$1 = parseFloat(numStr);
-			if (Number.isNaN(value$1)) return {
+			const value = parseFloat(numStr);
+			if (Number.isNaN(value)) return {
 				type: "Float",
 				value: err(invalidNumberFormat(this.span()))
 			};
 			return {
 				type: "Float",
-				value: ok(value$1)
+				value: ok(value)
 			};
 		}
 		const value = parseInt(numStr, 10);
@@ -5858,25 +5858,25 @@ var Lexer = class {
 	* Gets the next token from the input.
 	*/
 	next() {
-		if (this.#peekedToken !== void 0) {
-			const peeked = this.#peekedToken;
-			this.#peekedToken = void 0;
+		if (this._peekedToken !== void 0) {
+			const peeked = this._peekedToken;
+			this._peekedToken = void 0;
 			return peeked;
 		}
-		this.#skipWhitespace();
-		this.#tokenStart = this.#position;
-		if (this.#position >= this.#source.length) return;
-		const ch = this.#source[this.#position];
+		this._skipWhitespace();
+		this._tokenStart = this._position;
+		if (this._position >= this._source.length) return;
+		const ch = this._source[this._position];
 		if (ch === void 0) return void 0;
-		const twoChar = this.#source.slice(this.#position, this.#position + 2);
-		if (this.#source.slice(this.#position, this.#position + 3) === "...") {
+		const twoChar = this._source.slice(this._position, this._position + 2);
+		if (this._source.slice(this._position, this._position + 3) === "...") {
 			this.bump(3);
 			return {
 				token: { type: "Ellipsis" },
 				span: this.span()
 			};
 		}
-		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" },
@@ -5945,7 +5945,7 @@ var Lexer = class {
 					return {
 						token: {
 							type: "HexBinaryRegex",
-							value: this.#parseHexBinaryRegex()
+							value: this._parseHexBinaryRegex()
 						},
 						span: this.span()
 					};
@@ -5953,7 +5953,7 @@ var Lexer = class {
 				return {
 					token: {
 						type: "HexPattern",
-						value: this.#parseHexPattern()
+						value: this._parseHexPattern()
 					},
 					span: this.span()
 				};
@@ -5962,7 +5962,7 @@ var Lexer = class {
 				return {
 					token: {
 						type: "SingleQuotedRegex",
-						value: this.#parseSingleQuotedRegex()
+						value: this._parseSingleQuotedRegex()
 					},
 					span: this.span()
 				};
@@ -6051,7 +6051,7 @@ var Lexer = class {
 				return {
 					token: {
 						type: "StringLiteral",
-						value: this.#parseStringLiteral()
+						value: this._parseStringLiteral()
 					},
 					span: this.span()
 				};
@@ -6060,7 +6060,7 @@ var Lexer = class {
 				return {
 					token: {
 						type: "Regex",
-						value: this.#parseRegex()
+						value: this._parseRegex()
 					},
 					span: this.span()
 				};
@@ -6069,7 +6069,7 @@ var Lexer = class {
 				return {
 					token: {
 						type: "Range",
-						value: this.#parseRange()
+						value: this._parseRange()
 					},
 					span: this.span()
 				};
@@ -6078,13 +6078,13 @@ var Lexer = class {
 				return {
 					token: {
 						type: "SingleQuotedPattern",
-						value: this.#parseSingleQuotedPattern()
+						value: this._parseSingleQuotedPattern()
 					},
 					span: this.span()
 				};
 			case "@": {
 				this.bump(1);
-				const start = this.#position;
+				const start = this._position;
 				let gc = this.peek();
 				if (gc !== void 0 && isIdentStart(gc)) {
 					gc = this.peek();
@@ -6095,7 +6095,7 @@ var Lexer = class {
 					return {
 						token: {
 							type: "GroupName",
-							name: this.#source.slice(start, this.#position)
+							name: this._source.slice(start, this._position)
 						},
 						span: this.span()
 					};
@@ -6109,29 +6109,29 @@ var Lexer = class {
 				};
 			}
 		}
-		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()
+					value: this._parseDatePattern()
 				},
 				span: this.span()
 			};
 		}
 		const nextChar = this.peekNext();
 		if (isDigit(ch) || ch === "-" && nextChar !== void 0 && isDigit(nextChar)) return {
-			token: this.#parseNumber(),
+			token: this._parseNumber(),
 			span: this.span()
 		};
 		if (isIdentStart(ch)) {
-			const start = this.#position;
+			const start = this._position;
 			let ic = this.peek();
 			while (ic !== void 0 && isIdentContinue(ic)) {
 				this.bump(1);
 				ic = this.peek();
 			}
-			const ident = this.#source.slice(start, this.#position);
+			const ident = this._source.slice(start, this._position);
 			const keyword = KEYWORDS.get(ident);
 			if (keyword !== void 0) return {
 				token: keyword,