inlang-plugin-rich-icu 0.1.0

package/dist/index.js

@@ -0,0 +1,4842 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  mod
+));
+
+// node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/typebox.js
+var require_typebox = __commonJS({
+  "node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/typebox.js"(exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Type = exports.JsonType = exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.TypeBuilder = exports.TypeBuilderError = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.TemplateLiteralDslParser = exports.TemplateLiteralGenerator = exports.TemplateLiteralGeneratorError = exports.TemplateLiteralFinite = exports.TemplateLiteralFiniteError = exports.TemplateLiteralParser = exports.TemplateLiteralParserError = exports.TemplateLiteralResolver = exports.TemplateLiteralPattern = exports.TemplateLiteralPatternError = exports.UnionResolver = exports.KeyArrayResolver = exports.KeyArrayResolverError = exports.KeyResolver = exports.ObjectMap = exports.Intrinsic = exports.IndexedAccessor = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.TypeExtendsError = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.ValueGuard = exports.FormatRegistry = exports.TypeBoxError = exports.TypeRegistry = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = exports.Kind = exports.Hint = exports.Optional = exports.Readonly = exports.Transform = void 0;
+    exports.Transform = /* @__PURE__ */ Symbol.for("TypeBox.Transform");
+    exports.Readonly = /* @__PURE__ */ Symbol.for("TypeBox.Readonly");
+    exports.Optional = /* @__PURE__ */ Symbol.for("TypeBox.Optional");
+    exports.Hint = /* @__PURE__ */ Symbol.for("TypeBox.Hint");
+    exports.Kind = /* @__PURE__ */ Symbol.for("TypeBox.Kind");
+    exports.PatternBoolean = "(true|false)";
+    exports.PatternNumber = "(0|[1-9][0-9]*)";
+    exports.PatternString = "(.*)";
+    exports.PatternBooleanExact = `^${exports.PatternBoolean}$`;
+    exports.PatternNumberExact = `^${exports.PatternNumber}$`;
+    exports.PatternStringExact = `^${exports.PatternString}$`;
+    var TypeRegistry;
+    (function(TypeRegistry2) {
+      const map = /* @__PURE__ */ new Map();
+      function Entries() {
+        return new Map(map);
+      }
+      TypeRegistry2.Entries = Entries;
+      function Clear() {
+        return map.clear();
+      }
+      TypeRegistry2.Clear = Clear;
+      function Delete(kind) {
+        return map.delete(kind);
+      }
+      TypeRegistry2.Delete = Delete;
+      function Has(kind) {
+        return map.has(kind);
+      }
+      TypeRegistry2.Has = Has;
+      function Set2(kind, func) {
+        map.set(kind, func);
+      }
+      TypeRegistry2.Set = Set2;
+      function Get(kind) {
+        return map.get(kind);
+      }
+      TypeRegistry2.Get = Get;
+    })(TypeRegistry || (exports.TypeRegistry = TypeRegistry = {}));
+    var TypeBoxError = class extends Error {
+      constructor(message) {
+        super(message);
+      }
+    };
+    exports.TypeBoxError = TypeBoxError;
+    var FormatRegistry;
+    (function(FormatRegistry2) {
+      const map = /* @__PURE__ */ new Map();
+      function Entries() {
+        return new Map(map);
+      }
+      FormatRegistry2.Entries = Entries;
+      function Clear() {
+        return map.clear();
+      }
+      FormatRegistry2.Clear = Clear;
+      function Delete(format) {
+        return map.delete(format);
+      }
+      FormatRegistry2.Delete = Delete;
+      function Has(format) {
+        return map.has(format);
+      }
+      FormatRegistry2.Has = Has;
+      function Set2(format, func) {
+        map.set(format, func);
+      }
+      FormatRegistry2.Set = Set2;
+      function Get(format) {
+        return map.get(format);
+      }
+      FormatRegistry2.Get = Get;
+    })(FormatRegistry || (exports.FormatRegistry = FormatRegistry = {}));
+    var ValueGuard;
+    (function(ValueGuard2) {
+      function IsArray(value) {
+        return Array.isArray(value);
+      }
+      ValueGuard2.IsArray = IsArray;
+      function IsBigInt(value) {
+        return typeof value === "bigint";
+      }
+      ValueGuard2.IsBigInt = IsBigInt;
+      function IsBoolean(value) {
+        return typeof value === "boolean";
+      }
+      ValueGuard2.IsBoolean = IsBoolean;
+      function IsDate(value) {
+        return value instanceof globalThis.Date;
+      }
+      ValueGuard2.IsDate = IsDate;
+      function IsNull(value) {
+        return value === null;
+      }
+      ValueGuard2.IsNull = IsNull;
+      function IsNumber(value) {
+        return typeof value === "number";
+      }
+      ValueGuard2.IsNumber = IsNumber;
+      function IsObject(value) {
+        return typeof value === "object" && value !== null;
+      }
+      ValueGuard2.IsObject = IsObject;
+      function IsString(value) {
+        return typeof value === "string";
+      }
+      ValueGuard2.IsString = IsString;
+      function IsUint8Array(value) {
+        return value instanceof globalThis.Uint8Array;
+      }
+      ValueGuard2.IsUint8Array = IsUint8Array;
+      function IsUndefined(value) {
+        return value === void 0;
+      }
+      ValueGuard2.IsUndefined = IsUndefined;
+    })(ValueGuard || (exports.ValueGuard = ValueGuard = {}));
+    var TypeGuardUnknownTypeError = class extends TypeBoxError {
+    };
+    exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
+    var TypeGuard;
+    (function(TypeGuard2) {
+      function IsPattern(value) {
+        try {
+          new RegExp(value);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      function IsControlCharacterFree(value) {
+        if (!ValueGuard.IsString(value))
+          return false;
+        for (let i = 0; i < value.length; i++) {
+          const code = value.charCodeAt(i);
+          if (code >= 7 && code <= 13 || code === 27 || code === 127) {
+            return false;
+          }
+        }
+        return true;
+      }
+      function IsAdditionalProperties(value) {
+        return IsOptionalBoolean(value) || TSchema(value);
+      }
+      function IsOptionalBigInt(value) {
+        return ValueGuard.IsUndefined(value) || ValueGuard.IsBigInt(value);
+      }
+      function IsOptionalNumber(value) {
+        return ValueGuard.IsUndefined(value) || ValueGuard.IsNumber(value);
+      }
+      function IsOptionalBoolean(value) {
+        return ValueGuard.IsUndefined(value) || ValueGuard.IsBoolean(value);
+      }
+      function IsOptionalString(value) {
+        return ValueGuard.IsUndefined(value) || ValueGuard.IsString(value);
+      }
+      function IsOptionalPattern(value) {
+        return ValueGuard.IsUndefined(value) || ValueGuard.IsString(value) && IsControlCharacterFree(value) && IsPattern(value);
+      }
+      function IsOptionalFormat(value) {
+        return ValueGuard.IsUndefined(value) || ValueGuard.IsString(value) && IsControlCharacterFree(value);
+      }
+      function IsOptionalSchema(value) {
+        return ValueGuard.IsUndefined(value) || TSchema(value);
+      }
+      function TAny(schema) {
+        return TKindOf(schema, "Any") && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TAny = TAny;
+      function TArray(schema) {
+        return TKindOf(schema, "Array") && schema.type === "array" && IsOptionalString(schema.$id) && TSchema(schema.items) && IsOptionalNumber(schema.minItems) && IsOptionalNumber(schema.maxItems) && IsOptionalBoolean(schema.uniqueItems) && IsOptionalSchema(schema.contains) && IsOptionalNumber(schema.minContains) && IsOptionalNumber(schema.maxContains);
+      }
+      TypeGuard2.TArray = TArray;
+      function TAsyncIterator(schema) {
+        return TKindOf(schema, "AsyncIterator") && schema.type === "AsyncIterator" && IsOptionalString(schema.$id) && TSchema(schema.items);
+      }
+      TypeGuard2.TAsyncIterator = TAsyncIterator;
+      function TBigInt(schema) {
+        return TKindOf(schema, "BigInt") && schema.type === "bigint" && IsOptionalString(schema.$id) && IsOptionalBigInt(schema.exclusiveMaximum) && IsOptionalBigInt(schema.exclusiveMinimum) && IsOptionalBigInt(schema.maximum) && IsOptionalBigInt(schema.minimum) && IsOptionalBigInt(schema.multipleOf);
+      }
+      TypeGuard2.TBigInt = TBigInt;
+      function TBoolean(schema) {
+        return TKindOf(schema, "Boolean") && schema.type === "boolean" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TBoolean = TBoolean;
+      function TConstructor(schema) {
+        return TKindOf(schema, "Constructor") && schema.type === "Constructor" && IsOptionalString(schema.$id) && ValueGuard.IsArray(schema.parameters) && schema.parameters.every((schema2) => TSchema(schema2)) && TSchema(schema.returns);
+      }
+      TypeGuard2.TConstructor = TConstructor;
+      function TDate(schema) {
+        return TKindOf(schema, "Date") && schema.type === "Date" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.exclusiveMaximumTimestamp) && IsOptionalNumber(schema.exclusiveMinimumTimestamp) && IsOptionalNumber(schema.maximumTimestamp) && IsOptionalNumber(schema.minimumTimestamp) && IsOptionalNumber(schema.multipleOfTimestamp);
+      }
+      TypeGuard2.TDate = TDate;
+      function TFunction(schema) {
+        return TKindOf(schema, "Function") && schema.type === "Function" && IsOptionalString(schema.$id) && ValueGuard.IsArray(schema.parameters) && schema.parameters.every((schema2) => TSchema(schema2)) && TSchema(schema.returns);
+      }
+      TypeGuard2.TFunction = TFunction;
+      function TInteger(schema) {
+        return TKindOf(schema, "Integer") && schema.type === "integer" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.exclusiveMaximum) && IsOptionalNumber(schema.exclusiveMinimum) && IsOptionalNumber(schema.maximum) && IsOptionalNumber(schema.minimum) && IsOptionalNumber(schema.multipleOf);
+      }
+      TypeGuard2.TInteger = TInteger;
+      function TIntersect(schema) {
+        return TKindOf(schema, "Intersect") && (ValueGuard.IsString(schema.type) && schema.type !== "object" ? false : true) && ValueGuard.IsArray(schema.allOf) && schema.allOf.every((schema2) => TSchema(schema2) && !TTransform(schema2)) && IsOptionalString(schema.type) && (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TIntersect = TIntersect;
+      function TIterator(schema) {
+        return TKindOf(schema, "Iterator") && schema.type === "Iterator" && IsOptionalString(schema.$id) && TSchema(schema.items);
+      }
+      TypeGuard2.TIterator = TIterator;
+      function TKindOf(schema, kind) {
+        return TKind(schema) && schema[exports.Kind] === kind;
+      }
+      TypeGuard2.TKindOf = TKindOf;
+      function TKind(schema) {
+        return ValueGuard.IsObject(schema) && exports.Kind in schema && ValueGuard.IsString(schema[exports.Kind]);
+      }
+      TypeGuard2.TKind = TKind;
+      function TLiteralString(schema) {
+        return TLiteral(schema) && ValueGuard.IsString(schema.const);
+      }
+      TypeGuard2.TLiteralString = TLiteralString;
+      function TLiteralNumber(schema) {
+        return TLiteral(schema) && ValueGuard.IsNumber(schema.const);
+      }
+      TypeGuard2.TLiteralNumber = TLiteralNumber;
+      function TLiteralBoolean(schema) {
+        return TLiteral(schema) && ValueGuard.IsBoolean(schema.const);
+      }
+      TypeGuard2.TLiteralBoolean = TLiteralBoolean;
+      function TLiteral(schema) {
+        return TKindOf(schema, "Literal") && IsOptionalString(schema.$id) && (ValueGuard.IsBoolean(schema.const) || ValueGuard.IsNumber(schema.const) || ValueGuard.IsString(schema.const));
+      }
+      TypeGuard2.TLiteral = TLiteral;
+      function TNever(schema) {
+        return TKindOf(schema, "Never") && ValueGuard.IsObject(schema.not) && Object.getOwnPropertyNames(schema.not).length === 0;
+      }
+      TypeGuard2.TNever = TNever;
+      function TNot(schema) {
+        return TKindOf(schema, "Not") && TSchema(schema.not);
+      }
+      TypeGuard2.TNot = TNot;
+      function TNull(schema) {
+        return TKindOf(schema, "Null") && schema.type === "null" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TNull = TNull;
+      function TNumber(schema) {
+        return TKindOf(schema, "Number") && schema.type === "number" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.exclusiveMaximum) && IsOptionalNumber(schema.exclusiveMinimum) && IsOptionalNumber(schema.maximum) && IsOptionalNumber(schema.minimum) && IsOptionalNumber(schema.multipleOf);
+      }
+      TypeGuard2.TNumber = TNumber;
+      function TObject(schema) {
+        return TKindOf(schema, "Object") && schema.type === "object" && IsOptionalString(schema.$id) && ValueGuard.IsObject(schema.properties) && IsAdditionalProperties(schema.additionalProperties) && IsOptionalNumber(schema.minProperties) && IsOptionalNumber(schema.maxProperties) && Object.entries(schema.properties).every(([key, schema2]) => IsControlCharacterFree(key) && TSchema(schema2));
+      }
+      TypeGuard2.TObject = TObject;
+      function TPromise(schema) {
+        return TKindOf(schema, "Promise") && schema.type === "Promise" && IsOptionalString(schema.$id) && TSchema(schema.item);
+      }
+      TypeGuard2.TPromise = TPromise;
+      function TRecord(schema) {
+        return TKindOf(schema, "Record") && schema.type === "object" && IsOptionalString(schema.$id) && IsAdditionalProperties(schema.additionalProperties) && ValueGuard.IsObject(schema.patternProperties) && ((schema2) => {
+          const keys = Object.getOwnPropertyNames(schema2.patternProperties);
+          return keys.length === 1 && IsPattern(keys[0]) && ValueGuard.IsObject(schema2.patternProperties) && TSchema(schema2.patternProperties[keys[0]]);
+        })(schema);
+      }
+      TypeGuard2.TRecord = TRecord;
+      function TRecursive(schema) {
+        return ValueGuard.IsObject(schema) && exports.Hint in schema && schema[exports.Hint] === "Recursive";
+      }
+      TypeGuard2.TRecursive = TRecursive;
+      function TRef(schema) {
+        return TKindOf(schema, "Ref") && IsOptionalString(schema.$id) && ValueGuard.IsString(schema.$ref);
+      }
+      TypeGuard2.TRef = TRef;
+      function TString(schema) {
+        return TKindOf(schema, "String") && schema.type === "string" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.minLength) && IsOptionalNumber(schema.maxLength) && IsOptionalPattern(schema.pattern) && IsOptionalFormat(schema.format);
+      }
+      TypeGuard2.TString = TString;
+      function TSymbol(schema) {
+        return TKindOf(schema, "Symbol") && schema.type === "symbol" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TSymbol = TSymbol;
+      function TTemplateLiteral(schema) {
+        return TKindOf(schema, "TemplateLiteral") && schema.type === "string" && ValueGuard.IsString(schema.pattern) && schema.pattern[0] === "^" && schema.pattern[schema.pattern.length - 1] === "$";
+      }
+      TypeGuard2.TTemplateLiteral = TTemplateLiteral;
+      function TThis(schema) {
+        return TKindOf(schema, "This") && IsOptionalString(schema.$id) && ValueGuard.IsString(schema.$ref);
+      }
+      TypeGuard2.TThis = TThis;
+      function TTransform(schema) {
+        return ValueGuard.IsObject(schema) && exports.Transform in schema;
+      }
+      TypeGuard2.TTransform = TTransform;
+      function TTuple(schema) {
+        return TKindOf(schema, "Tuple") && schema.type === "array" && IsOptionalString(schema.$id) && ValueGuard.IsNumber(schema.minItems) && ValueGuard.IsNumber(schema.maxItems) && schema.minItems === schema.maxItems && // empty
+        (ValueGuard.IsUndefined(schema.items) && ValueGuard.IsUndefined(schema.additionalItems) && schema.minItems === 0 || ValueGuard.IsArray(schema.items) && schema.items.every((schema2) => TSchema(schema2)));
+      }
+      TypeGuard2.TTuple = TTuple;
+      function TUndefined(schema) {
+        return TKindOf(schema, "Undefined") && schema.type === "undefined" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TUndefined = TUndefined;
+      function TUnionLiteral(schema) {
+        return TUnion(schema) && schema.anyOf.every((schema2) => TLiteralString(schema2) || TLiteralNumber(schema2));
+      }
+      TypeGuard2.TUnionLiteral = TUnionLiteral;
+      function TUnion(schema) {
+        return TKindOf(schema, "Union") && IsOptionalString(schema.$id) && ValueGuard.IsObject(schema) && ValueGuard.IsArray(schema.anyOf) && schema.anyOf.every((schema2) => TSchema(schema2));
+      }
+      TypeGuard2.TUnion = TUnion;
+      function TUint8Array(schema) {
+        return TKindOf(schema, "Uint8Array") && schema.type === "Uint8Array" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.minByteLength) && IsOptionalNumber(schema.maxByteLength);
+      }
+      TypeGuard2.TUint8Array = TUint8Array;
+      function TUnknown(schema) {
+        return TKindOf(schema, "Unknown") && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TUnknown = TUnknown;
+      function TUnsafe(schema) {
+        return TKindOf(schema, "Unsafe");
+      }
+      TypeGuard2.TUnsafe = TUnsafe;
+      function TVoid(schema) {
+        return TKindOf(schema, "Void") && schema.type === "void" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TVoid = TVoid;
+      function TReadonly(schema) {
+        return ValueGuard.IsObject(schema) && schema[exports.Readonly] === "Readonly";
+      }
+      TypeGuard2.TReadonly = TReadonly;
+      function TOptional(schema) {
+        return ValueGuard.IsObject(schema) && schema[exports.Optional] === "Optional";
+      }
+      TypeGuard2.TOptional = TOptional;
+      function TSchema(schema) {
+        return ValueGuard.IsObject(schema) && (TAny(schema) || TArray(schema) || TBoolean(schema) || TBigInt(schema) || TAsyncIterator(schema) || TConstructor(schema) || TDate(schema) || TFunction(schema) || TInteger(schema) || TIntersect(schema) || TIterator(schema) || TLiteral(schema) || TNever(schema) || TNot(schema) || TNull(schema) || TNumber(schema) || TObject(schema) || TPromise(schema) || TRecord(schema) || TRef(schema) || TString(schema) || TSymbol(schema) || TTemplateLiteral(schema) || TThis(schema) || TTuple(schema) || TUndefined(schema) || TUnion(schema) || TUint8Array(schema) || TUnknown(schema) || TUnsafe(schema) || TVoid(schema) || TKind(schema) && TypeRegistry.Has(schema[exports.Kind]));
+      }
+      TypeGuard2.TSchema = TSchema;
+    })(TypeGuard || (exports.TypeGuard = TypeGuard = {}));
+    var ExtendsUndefined;
+    (function(ExtendsUndefined2) {
+      function Check(schema) {
+        return schema[exports.Kind] === "Intersect" ? schema.allOf.every((schema2) => Check(schema2)) : schema[exports.Kind] === "Union" ? schema.anyOf.some((schema2) => Check(schema2)) : schema[exports.Kind] === "Undefined" ? true : schema[exports.Kind] === "Not" ? !Check(schema.not) : false;
+      }
+      ExtendsUndefined2.Check = Check;
+    })(ExtendsUndefined || (exports.ExtendsUndefined = ExtendsUndefined = {}));
+    var TypeExtendsError = class extends TypeBoxError {
+    };
+    exports.TypeExtendsError = TypeExtendsError;
+    var TypeExtendsResult;
+    (function(TypeExtendsResult2) {
+      TypeExtendsResult2[TypeExtendsResult2["Union"] = 0] = "Union";
+      TypeExtendsResult2[TypeExtendsResult2["True"] = 1] = "True";
+      TypeExtendsResult2[TypeExtendsResult2["False"] = 2] = "False";
+    })(TypeExtendsResult || (exports.TypeExtendsResult = TypeExtendsResult = {}));
+    var TypeExtends;
+    (function(TypeExtends2) {
+      function IntoBooleanResult(result) {
+        return result === TypeExtendsResult.False ? result : TypeExtendsResult.True;
+      }
+      function Throw(message) {
+        throw new TypeExtendsError(message);
+      }
+      function IsStructuralRight(right) {
+        return TypeGuard.TNever(right) || TypeGuard.TIntersect(right) || TypeGuard.TUnion(right) || TypeGuard.TUnknown(right) || TypeGuard.TAny(right);
+      }
+      function StructuralRight(left, right) {
+        return TypeGuard.TNever(right) ? TNeverRight() : TypeGuard.TIntersect(right) ? TIntersectRight(left, right) : TypeGuard.TUnion(right) ? TUnionRight(left, right) : TypeGuard.TUnknown(right) ? TUnknownRight() : TypeGuard.TAny(right) ? TAnyRight() : Throw("StructuralRight");
+      }
+      function TAnyRight(left, right) {
+        return TypeExtendsResult.True;
+      }
+      function TAny(left, right) {
+        return TypeGuard.TIntersect(right) ? TIntersectRight(left, right) : TypeGuard.TUnion(right) && right.anyOf.some((schema) => TypeGuard.TAny(schema) || TypeGuard.TUnknown(schema)) ? TypeExtendsResult.True : TypeGuard.TUnion(right) ? TypeExtendsResult.Union : TypeGuard.TUnknown(right) ? TypeExtendsResult.True : TypeGuard.TAny(right) ? TypeExtendsResult.True : TypeExtendsResult.Union;
+      }
+      function TArrayRight(left, right) {
+        return TypeGuard.TUnknown(left) ? TypeExtendsResult.False : TypeGuard.TAny(left) ? TypeExtendsResult.Union : TypeGuard.TNever(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TArray(left, right) {
+        return TypeGuard.TObject(right) && IsObjectArrayLike(right) ? TypeExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : !TypeGuard.TArray(right) ? TypeExtendsResult.False : IntoBooleanResult(Visit(left.items, right.items));
+      }
+      function TAsyncIterator(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : !TypeGuard.TAsyncIterator(right) ? TypeExtendsResult.False : IntoBooleanResult(Visit(left.items, right.items));
+      }
+      function TBigInt(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TBigInt(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TBooleanRight(left, right) {
+        return TypeGuard.TLiteral(left) && ValueGuard.IsBoolean(left.const) ? TypeExtendsResult.True : TypeGuard.TBoolean(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TBoolean(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TBoolean(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TConstructor(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : !TypeGuard.TConstructor(right) ? TypeExtendsResult.False : left.parameters.length > right.parameters.length ? TypeExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True) ? TypeExtendsResult.False : IntoBooleanResult(Visit(left.returns, right.returns));
+      }
+      function TDate(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TDate(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TFunction(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : !TypeGuard.TFunction(right) ? TypeExtendsResult.False : left.parameters.length > right.parameters.length ? TypeExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True) ? TypeExtendsResult.False : IntoBooleanResult(Visit(left.returns, right.returns));
+      }
+      function TIntegerRight(left, right) {
+        return TypeGuard.TLiteral(left) && ValueGuard.IsNumber(left.const) ? TypeExtendsResult.True : TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TInteger(left, right) {
+        return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeExtendsResult.False;
+      }
+      function TIntersectRight(left, right) {
+        return right.allOf.every((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TIntersect(left, right) {
+        return left.allOf.some((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TIterator(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : !TypeGuard.TIterator(right) ? TypeExtendsResult.False : IntoBooleanResult(Visit(left.items, right.items));
+      }
+      function TLiteral(left, right) {
+        return TypeGuard.TLiteral(right) && right.const === left.const ? TypeExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TString(right) ? TStringRight(left) : TypeGuard.TNumber(right) ? TNumberRight(left) : TypeGuard.TInteger(right) ? TIntegerRight(left) : TypeGuard.TBoolean(right) ? TBooleanRight(left) : TypeExtendsResult.False;
+      }
+      function TNeverRight(left, right) {
+        return TypeExtendsResult.False;
+      }
+      function TNever(left, right) {
+        return TypeExtendsResult.True;
+      }
+      function UnwrapTNot(schema) {
+        let [current, depth] = [schema, 0];
+        while (true) {
+          if (!TypeGuard.TNot(current))
+            break;
+          current = current.not;
+          depth += 1;
+        }
+        return depth % 2 === 0 ? current : exports.Type.Unknown();
+      }
+      function TNot(left, right) {
+        return TypeGuard.TNot(left) ? Visit(UnwrapTNot(left), right) : TypeGuard.TNot(right) ? Visit(left, UnwrapTNot(right)) : Throw("Invalid fallthrough for Not");
+      }
+      function TNull(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TNull(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TNumberRight(left, right) {
+        return TypeGuard.TLiteralNumber(left) ? TypeExtendsResult.True : TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TNumber(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function IsObjectPropertyCount(schema, count) {
+        return Object.getOwnPropertyNames(schema.properties).length === count;
+      }
+      function IsObjectStringLike(schema) {
+        return IsObjectArrayLike(schema);
+      }
+      function IsObjectSymbolLike(schema) {
+        return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "description" in schema.properties && TypeGuard.TUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && (TypeGuard.TString(schema.properties.description.anyOf[0]) && TypeGuard.TUndefined(schema.properties.description.anyOf[1]) || TypeGuard.TString(schema.properties.description.anyOf[1]) && TypeGuard.TUndefined(schema.properties.description.anyOf[0]));
+      }
+      function IsObjectNumberLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+      }
+      function IsObjectBooleanLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+      }
+      function IsObjectBigIntLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+      }
+      function IsObjectDateLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+      }
+      function IsObjectUint8ArrayLike(schema) {
+        return IsObjectArrayLike(schema);
+      }
+      function IsObjectFunctionLike(schema) {
+        const length = exports.Type.Number();
+        return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit(schema.properties["length"], length)) === TypeExtendsResult.True;
+      }
+      function IsObjectConstructorLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+      }
+      function IsObjectArrayLike(schema) {
+        const length = exports.Type.Number();
+        return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit(schema.properties["length"], length)) === TypeExtendsResult.True;
+      }
+      function IsObjectPromiseLike(schema) {
+        const then = exports.Type.Function([exports.Type.Any()], exports.Type.Any());
+        return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "then" in schema.properties && IntoBooleanResult(Visit(schema.properties["then"], then)) === TypeExtendsResult.True;
+      }
+      function Property(left, right) {
+        return Visit(left, right) === TypeExtendsResult.False ? TypeExtendsResult.False : TypeGuard.TOptional(left) && !TypeGuard.TOptional(right) ? TypeExtendsResult.False : TypeExtendsResult.True;
+      }
+      function TObjectRight(left, right) {
+        return TypeGuard.TUnknown(left) ? TypeExtendsResult.False : TypeGuard.TAny(left) ? TypeExtendsResult.Union : TypeGuard.TNever(left) || TypeGuard.TLiteralString(left) && IsObjectStringLike(right) || TypeGuard.TLiteralNumber(left) && IsObjectNumberLike(right) || TypeGuard.TLiteralBoolean(left) && IsObjectBooleanLike(right) || TypeGuard.TSymbol(left) && IsObjectSymbolLike(right) || TypeGuard.TBigInt(left) && IsObjectBigIntLike(right) || TypeGuard.TString(left) && IsObjectStringLike(right) || TypeGuard.TSymbol(left) && IsObjectSymbolLike(right) || TypeGuard.TNumber(left) && IsObjectNumberLike(right) || TypeGuard.TInteger(left) && IsObjectNumberLike(right) || TypeGuard.TBoolean(left) && IsObjectBooleanLike(right) || TypeGuard.TUint8Array(left) && IsObjectUint8ArrayLike(right) || TypeGuard.TDate(left) && IsObjectDateLike(right) || TypeGuard.TConstructor(left) && IsObjectConstructorLike(right) || TypeGuard.TFunction(left) && IsObjectFunctionLike(right) ? TypeExtendsResult.True : TypeGuard.TRecord(left) && TypeGuard.TString(RecordKey(left)) ? (() => {
+          return right[exports.Hint] === "Record" ? TypeExtendsResult.True : TypeExtendsResult.False;
+        })() : TypeGuard.TRecord(left) && TypeGuard.TNumber(RecordKey(left)) ? (() => {
+          return IsObjectPropertyCount(right, 0) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        })() : TypeExtendsResult.False;
+      }
+      function TObject(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : !TypeGuard.TObject(right) ? TypeExtendsResult.False : (() => {
+          for (const key of Object.getOwnPropertyNames(right.properties)) {
+            if (!(key in left.properties) && !TypeGuard.TOptional(right.properties[key])) {
+              return TypeExtendsResult.False;
+            }
+            if (TypeGuard.TOptional(right.properties[key])) {
+              return TypeExtendsResult.True;
+            }
+            if (Property(left.properties[key], right.properties[key]) === TypeExtendsResult.False) {
+              return TypeExtendsResult.False;
+            }
+          }
+          return TypeExtendsResult.True;
+        })();
+      }
+      function TPromise(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) && IsObjectPromiseLike(right) ? TypeExtendsResult.True : !TypeGuard.TPromise(right) ? TypeExtendsResult.False : IntoBooleanResult(Visit(left.item, right.item));
+      }
+      function RecordKey(schema) {
+        return exports.PatternNumberExact in schema.patternProperties ? exports.Type.Number() : exports.PatternStringExact in schema.patternProperties ? exports.Type.String() : Throw("Unknown record key pattern");
+      }
+      function RecordValue(schema) {
+        return exports.PatternNumberExact in schema.patternProperties ? schema.patternProperties[exports.PatternNumberExact] : exports.PatternStringExact in schema.patternProperties ? schema.patternProperties[exports.PatternStringExact] : Throw("Unable to get record value schema");
+      }
+      function TRecordRight(left, right) {
+        const [Key, Value] = [RecordKey(right), RecordValue(right)];
+        return TypeGuard.TLiteralString(left) && TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === TypeExtendsResult.True ? TypeExtendsResult.True : TypeGuard.TUint8Array(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) : TypeGuard.TString(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) : TypeGuard.TArray(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) : TypeGuard.TObject(left) ? (() => {
+          for (const key of Object.getOwnPropertyNames(left.properties)) {
+            if (Property(Value, left.properties[key]) === TypeExtendsResult.False) {
+              return TypeExtendsResult.False;
+            }
+          }
+          return TypeExtendsResult.True;
+        })() : TypeExtendsResult.False;
+      }
+      function TRecord(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : !TypeGuard.TRecord(right) ? TypeExtendsResult.False : Visit(RecordValue(left), RecordValue(right));
+      }
+      function TStringRight(left, right) {
+        return TypeGuard.TLiteral(left) && ValueGuard.IsString(left.const) ? TypeExtendsResult.True : TypeGuard.TString(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TString(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TString(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TSymbol(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TSymbol(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TTemplateLiteral(left, right) {
+        return TypeGuard.TTemplateLiteral(left) ? Visit(TemplateLiteralResolver.Resolve(left), right) : TypeGuard.TTemplateLiteral(right) ? Visit(left, TemplateLiteralResolver.Resolve(right)) : Throw("Invalid fallthrough for TemplateLiteral");
+      }
+      function IsArrayOfTuple(left, right) {
+        return TypeGuard.TArray(right) && left.items !== void 0 && left.items.every((schema) => Visit(schema, right.items) === TypeExtendsResult.True);
+      }
+      function TTupleRight(left, right) {
+        return TypeGuard.TNever(left) ? TypeExtendsResult.True : TypeGuard.TUnknown(left) ? TypeExtendsResult.False : TypeGuard.TAny(left) ? TypeExtendsResult.Union : TypeExtendsResult.False;
+      }
+      function TTuple(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) && IsObjectArrayLike(right) ? TypeExtendsResult.True : TypeGuard.TArray(right) && IsArrayOfTuple(left, right) ? TypeExtendsResult.True : !TypeGuard.TTuple(right) ? TypeExtendsResult.False : ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items) || !ValueGuard.IsUndefined(left.items) && ValueGuard.IsUndefined(right.items) ? TypeExtendsResult.False : ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items) ? TypeExtendsResult.True : left.items.every((schema, index) => Visit(schema, right.items[index]) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TUint8Array(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TUint8Array(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TUndefined(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TVoid(right) ? VoidRight(left) : TypeGuard.TUndefined(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TUnionRight(left, right) {
+        return right.anyOf.some((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TUnion(left, right) {
+        return left.anyOf.every((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TUnknownRight(left, right) {
+        return TypeExtendsResult.True;
+      }
+      function TUnknown(left, right) {
+        return TypeGuard.TNever(right) ? TNeverRight() : TypeGuard.TIntersect(right) ? TIntersectRight(left, right) : TypeGuard.TUnion(right) ? TUnionRight(left, right) : TypeGuard.TAny(right) ? TAnyRight() : TypeGuard.TString(right) ? TStringRight(left) : TypeGuard.TNumber(right) ? TNumberRight(left) : TypeGuard.TInteger(right) ? TIntegerRight(left) : TypeGuard.TBoolean(right) ? TBooleanRight(left) : TypeGuard.TArray(right) ? TArrayRight(left) : TypeGuard.TTuple(right) ? TTupleRight(left) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TUnknown(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function VoidRight(left, right) {
+        return TypeGuard.TUndefined(left) ? TypeExtendsResult.True : TypeGuard.TUndefined(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TVoid(left, right) {
+        return TypeGuard.TIntersect(right) ? TIntersectRight(left, right) : TypeGuard.TUnion(right) ? TUnionRight(left, right) : TypeGuard.TUnknown(right) ? TUnknownRight() : TypeGuard.TAny(right) ? TAnyRight() : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function Visit(left, right) {
+        return (
+          // resolvable
+          TypeGuard.TTemplateLiteral(left) || TypeGuard.TTemplateLiteral(right) ? TTemplateLiteral(left, right) : TypeGuard.TNot(left) || TypeGuard.TNot(right) ? TNot(left, right) : (
+            // standard
+            TypeGuard.TAny(left) ? TAny(left, right) : TypeGuard.TArray(left) ? TArray(left, right) : TypeGuard.TBigInt(left) ? TBigInt(left, right) : TypeGuard.TBoolean(left) ? TBoolean(left, right) : TypeGuard.TAsyncIterator(left) ? TAsyncIterator(left, right) : TypeGuard.TConstructor(left) ? TConstructor(left, right) : TypeGuard.TDate(left) ? TDate(left, right) : TypeGuard.TFunction(left) ? TFunction(left, right) : TypeGuard.TInteger(left) ? TInteger(left, right) : TypeGuard.TIntersect(left) ? TIntersect(left, right) : TypeGuard.TIterator(left) ? TIterator(left, right) : TypeGuard.TLiteral(left) ? TLiteral(left, right) : TypeGuard.TNever(left) ? TNever() : TypeGuard.TNull(left) ? TNull(left, right) : TypeGuard.TNumber(left) ? TNumber(left, right) : TypeGuard.TObject(left) ? TObject(left, right) : TypeGuard.TRecord(left) ? TRecord(left, right) : TypeGuard.TString(left) ? TString(left, right) : TypeGuard.TSymbol(left) ? TSymbol(left, right) : TypeGuard.TTuple(left) ? TTuple(left, right) : TypeGuard.TPromise(left) ? TPromise(left, right) : TypeGuard.TUint8Array(left) ? TUint8Array(left, right) : TypeGuard.TUndefined(left) ? TUndefined(left, right) : TypeGuard.TUnion(left) ? TUnion(left, right) : TypeGuard.TUnknown(left) ? TUnknown(left, right) : TypeGuard.TVoid(left) ? TVoid(left, right) : Throw(`Unknown left type operand '${left[exports.Kind]}'`)
+          )
+        );
+      }
+      function Extends(left, right) {
+        return Visit(left, right);
+      }
+      TypeExtends2.Extends = Extends;
+    })(TypeExtends || (exports.TypeExtends = TypeExtends = {}));
+    var TypeClone;
+    (function(TypeClone2) {
+      function ArrayType(value) {
+        return value.map((value2) => Visit(value2));
+      }
+      function DateType(value) {
+        return new Date(value.getTime());
+      }
+      function Uint8ArrayType(value) {
+        return new Uint8Array(value);
+      }
+      function ObjectType(value) {
+        const clonedProperties = Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
+        const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
+        return { ...clonedProperties, ...clonedSymbols };
+      }
+      function Visit(value) {
+        return ValueGuard.IsArray(value) ? ArrayType(value) : ValueGuard.IsDate(value) ? DateType(value) : ValueGuard.IsUint8Array(value) ? Uint8ArrayType(value) : ValueGuard.IsObject(value) ? ObjectType(value) : value;
+      }
+      function Rest(schemas) {
+        return schemas.map((schema) => Type2(schema));
+      }
+      TypeClone2.Rest = Rest;
+      function Type2(schema, options = {}) {
+        return { ...Visit(schema), ...options };
+      }
+      TypeClone2.Type = Type2;
+    })(TypeClone || (exports.TypeClone = TypeClone = {}));
+    var IndexedAccessor;
+    (function(IndexedAccessor2) {
+      function OptionalUnwrap(schema) {
+        return schema.map((schema2) => {
+          const { [exports.Optional]: _, ...clone } = TypeClone.Type(schema2);
+          return clone;
+        });
+      }
+      function IsIntersectOptional(schema) {
+        return schema.every((schema2) => TypeGuard.TOptional(schema2));
+      }
+      function IsUnionOptional(schema) {
+        return schema.some((schema2) => TypeGuard.TOptional(schema2));
+      }
+      function ResolveIntersect(schema) {
+        return IsIntersectOptional(schema.allOf) ? exports.Type.Optional(exports.Type.Intersect(OptionalUnwrap(schema.allOf))) : schema;
+      }
+      function ResolveUnion(schema) {
+        return IsUnionOptional(schema.anyOf) ? exports.Type.Optional(exports.Type.Union(OptionalUnwrap(schema.anyOf))) : schema;
+      }
+      function ResolveOptional(schema) {
+        return schema[exports.Kind] === "Intersect" ? ResolveIntersect(schema) : schema[exports.Kind] === "Union" ? ResolveUnion(schema) : schema;
+      }
+      function TIntersect(schema, key) {
+        const resolved = schema.allOf.reduce((acc, schema2) => {
+          const indexed = Visit(schema2, key);
+          return indexed[exports.Kind] === "Never" ? acc : [...acc, indexed];
+        }, []);
+        return ResolveOptional(exports.Type.Intersect(resolved));
+      }
+      function TUnion(schema, key) {
+        const resolved = schema.anyOf.map((schema2) => Visit(schema2, key));
+        return ResolveOptional(exports.Type.Union(resolved));
+      }
+      function TObject(schema, key) {
+        const property = schema.properties[key];
+        return ValueGuard.IsUndefined(property) ? exports.Type.Never() : exports.Type.Union([property]);
+      }
+      function TTuple(schema, key) {
+        const items = schema.items;
+        if (ValueGuard.IsUndefined(items))
+          return exports.Type.Never();
+        const element = items[key];
+        if (ValueGuard.IsUndefined(element))
+          return exports.Type.Never();
+        return element;
+      }
+      function Visit(schema, key) {
+        return schema[exports.Kind] === "Intersect" ? TIntersect(schema, key) : schema[exports.Kind] === "Union" ? TUnion(schema, key) : schema[exports.Kind] === "Object" ? TObject(schema, key) : schema[exports.Kind] === "Tuple" ? TTuple(schema, key) : exports.Type.Never();
+      }
+      function Resolve(schema, keys, options = {}) {
+        const resolved = keys.map((key) => Visit(schema, key.toString()));
+        return ResolveOptional(exports.Type.Union(resolved, options));
+      }
+      IndexedAccessor2.Resolve = Resolve;
+    })(IndexedAccessor || (exports.IndexedAccessor = IndexedAccessor = {}));
+    var Intrinsic;
+    (function(Intrinsic2) {
+      function Uncapitalize(value) {
+        const [first, rest] = [value.slice(0, 1), value.slice(1)];
+        return `${first.toLowerCase()}${rest}`;
+      }
+      function Capitalize(value) {
+        const [first, rest] = [value.slice(0, 1), value.slice(1)];
+        return `${first.toUpperCase()}${rest}`;
+      }
+      function Uppercase(value) {
+        return value.toUpperCase();
+      }
+      function Lowercase(value) {
+        return value.toLowerCase();
+      }
+      function IntrinsicTemplateLiteral(schema, mode) {
+        const expression = TemplateLiteralParser.ParseExact(schema.pattern);
+        const finite = TemplateLiteralFinite.Check(expression);
+        if (!finite)
+          return { ...schema, pattern: IntrinsicLiteral(schema.pattern, mode) };
+        const strings = [...TemplateLiteralGenerator.Generate(expression)];
+        const literals = strings.map((value) => exports.Type.Literal(value));
+        const mapped = IntrinsicRest(literals, mode);
+        const union = exports.Type.Union(mapped);
+        return exports.Type.TemplateLiteral([union]);
+      }
+      function IntrinsicLiteral(value, mode) {
+        return typeof value === "string" ? mode === "Uncapitalize" ? Uncapitalize(value) : mode === "Capitalize" ? Capitalize(value) : mode === "Uppercase" ? Uppercase(value) : mode === "Lowercase" ? Lowercase(value) : value : value.toString();
+      }
+      function IntrinsicRest(schema, mode) {
+        if (schema.length === 0)
+          return [];
+        const [L, ...R] = schema;
+        return [Map2(L, mode), ...IntrinsicRest(R, mode)];
+      }
+      function Visit(schema, mode) {
+        return TypeGuard.TTemplateLiteral(schema) ? IntrinsicTemplateLiteral(schema, mode) : TypeGuard.TUnion(schema) ? exports.Type.Union(IntrinsicRest(schema.anyOf, mode)) : TypeGuard.TLiteral(schema) ? exports.Type.Literal(IntrinsicLiteral(schema.const, mode)) : schema;
+      }
+      function Map2(schema, mode) {
+        return Visit(schema, mode);
+      }
+      Intrinsic2.Map = Map2;
+    })(Intrinsic || (exports.Intrinsic = Intrinsic = {}));
+    var ObjectMap;
+    (function(ObjectMap2) {
+      function TIntersect(schema, callback) {
+        return exports.Type.Intersect(schema.allOf.map((inner) => Visit(inner, callback)), { ...schema });
+      }
+      function TUnion(schema, callback) {
+        return exports.Type.Union(schema.anyOf.map((inner) => Visit(inner, callback)), { ...schema });
+      }
+      function TObject(schema, callback) {
+        return callback(schema);
+      }
+      function Visit(schema, callback) {
+        return schema[exports.Kind] === "Intersect" ? TIntersect(schema, callback) : schema[exports.Kind] === "Union" ? TUnion(schema, callback) : schema[exports.Kind] === "Object" ? TObject(schema, callback) : schema;
+      }
+      function Map2(schema, callback, options) {
+        return { ...Visit(TypeClone.Type(schema), callback), ...options };
+      }
+      ObjectMap2.Map = Map2;
+    })(ObjectMap || (exports.ObjectMap = ObjectMap = {}));
+    var KeyResolver;
+    (function(KeyResolver2) {
+      function UnwrapPattern(key) {
+        return key[0] === "^" && key[key.length - 1] === "$" ? key.slice(1, key.length - 1) : key;
+      }
+      function TIntersect(schema, options) {
+        return schema.allOf.reduce((acc, schema2) => [...acc, ...Visit(schema2, options)], []);
+      }
+      function TUnion(schema, options) {
+        const sets = schema.anyOf.map((inner) => Visit(inner, options));
+        return [...sets.reduce((set, outer) => outer.map((key) => sets.every((inner) => inner.includes(key)) ? set.add(key) : set)[0], /* @__PURE__ */ new Set())];
+      }
+      function TObject(schema, options) {
+        return Object.getOwnPropertyNames(schema.properties);
+      }
+      function TRecord(schema, options) {
+        return options.includePatterns ? Object.getOwnPropertyNames(schema.patternProperties) : [];
+      }
+      function Visit(schema, options) {
+        return TypeGuard.TIntersect(schema) ? TIntersect(schema, options) : TypeGuard.TUnion(schema) ? TUnion(schema, options) : TypeGuard.TObject(schema) ? TObject(schema) : TypeGuard.TRecord(schema) ? TRecord(schema, options) : [];
+      }
+      function ResolveKeys(schema, options) {
+        return [...new Set(Visit(schema, options))];
+      }
+      KeyResolver2.ResolveKeys = ResolveKeys;
+      function ResolvePattern(schema) {
+        const keys = ResolveKeys(schema, { includePatterns: true });
+        const pattern = keys.map((key) => `(${UnwrapPattern(key)})`);
+        return `^(${pattern.join("|")})$`;
+      }
+      KeyResolver2.ResolvePattern = ResolvePattern;
+    })(KeyResolver || (exports.KeyResolver = KeyResolver = {}));
+    var KeyArrayResolverError = class extends TypeBoxError {
+    };
+    exports.KeyArrayResolverError = KeyArrayResolverError;
+    var KeyArrayResolver;
+    (function(KeyArrayResolver2) {
+      function Resolve(schema) {
+        return Array.isArray(schema) ? schema : TypeGuard.TUnionLiteral(schema) ? schema.anyOf.map((schema2) => schema2.const.toString()) : TypeGuard.TLiteral(schema) ? [schema.const] : TypeGuard.TTemplateLiteral(schema) ? (() => {
+          const expression = TemplateLiteralParser.ParseExact(schema.pattern);
+          if (!TemplateLiteralFinite.Check(expression))
+            throw new KeyArrayResolverError("Cannot resolve keys from infinite template expression");
+          return [...TemplateLiteralGenerator.Generate(expression)];
+        })() : [];
+      }
+      KeyArrayResolver2.Resolve = Resolve;
+    })(KeyArrayResolver || (exports.KeyArrayResolver = KeyArrayResolver = {}));
+    var UnionResolver;
+    (function(UnionResolver2) {
+      function* TUnion(union) {
+        for (const schema of union.anyOf) {
+          if (schema[exports.Kind] === "Union") {
+            yield* TUnion(schema);
+          } else {
+            yield schema;
+          }
+        }
+      }
+      function Resolve(union) {
+        return exports.Type.Union([...TUnion(union)], { ...union });
+      }
+      UnionResolver2.Resolve = Resolve;
+    })(UnionResolver || (exports.UnionResolver = UnionResolver = {}));
+    var TemplateLiteralPatternError = class extends TypeBoxError {
+    };
+    exports.TemplateLiteralPatternError = TemplateLiteralPatternError;
+    var TemplateLiteralPattern;
+    (function(TemplateLiteralPattern2) {
+      function Throw(message) {
+        throw new TemplateLiteralPatternError(message);
+      }
+      function Escape(value) {
+        return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      }
+      function Visit(schema, acc) {
+        return TypeGuard.TTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) : TypeGuard.TUnion(schema) ? `(${schema.anyOf.map((schema2) => Visit(schema2, acc)).join("|")})` : TypeGuard.TNumber(schema) ? `${acc}${exports.PatternNumber}` : TypeGuard.TInteger(schema) ? `${acc}${exports.PatternNumber}` : TypeGuard.TBigInt(schema) ? `${acc}${exports.PatternNumber}` : TypeGuard.TString(schema) ? `${acc}${exports.PatternString}` : TypeGuard.TLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` : TypeGuard.TBoolean(schema) ? `${acc}${exports.PatternBoolean}` : Throw(`Unexpected Kind '${schema[exports.Kind]}'`);
+      }
+      function Create(kinds) {
+        return `^${kinds.map((schema) => Visit(schema, "")).join("")}$`;
+      }
+      TemplateLiteralPattern2.Create = Create;
+    })(TemplateLiteralPattern || (exports.TemplateLiteralPattern = TemplateLiteralPattern = {}));
+    var TemplateLiteralResolver;
+    (function(TemplateLiteralResolver2) {
+      function Resolve(template) {
+        const expression = TemplateLiteralParser.ParseExact(template.pattern);
+        if (!TemplateLiteralFinite.Check(expression))
+          return exports.Type.String();
+        const literals = [...TemplateLiteralGenerator.Generate(expression)].map((value) => exports.Type.Literal(value));
+        return exports.Type.Union(literals);
+      }
+      TemplateLiteralResolver2.Resolve = Resolve;
+    })(TemplateLiteralResolver || (exports.TemplateLiteralResolver = TemplateLiteralResolver = {}));
+    var TemplateLiteralParserError = class extends TypeBoxError {
+    };
+    exports.TemplateLiteralParserError = TemplateLiteralParserError;
+    var TemplateLiteralParser;
+    (function(TemplateLiteralParser2) {
+      function IsNonEscaped(pattern, index, char) {
+        return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
+      }
+      function IsOpenParen(pattern, index) {
+        return IsNonEscaped(pattern, index, "(");
+      }
+      function IsCloseParen(pattern, index) {
+        return IsNonEscaped(pattern, index, ")");
+      }
+      function IsSeparator(pattern, index) {
+        return IsNonEscaped(pattern, index, "|");
+      }
+      function IsGroup(pattern) {
+        if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
+          return false;
+        let count = 0;
+        for (let index = 0; index < pattern.length; index++) {
+          if (IsOpenParen(pattern, index))
+            count += 1;
+          if (IsCloseParen(pattern, index))
+            count -= 1;
+          if (count === 0 && index !== pattern.length - 1)
+            return false;
+        }
+        return true;
+      }
+      function InGroup(pattern) {
+        return pattern.slice(1, pattern.length - 1);
+      }
+      function IsPrecedenceOr(pattern) {
+        let count = 0;
+        for (let index = 0; index < pattern.length; index++) {
+          if (IsOpenParen(pattern, index))
+            count += 1;
+          if (IsCloseParen(pattern, index))
+            count -= 1;
+          if (IsSeparator(pattern, index) && count === 0)
+            return true;
+        }
+        return false;
+      }
+      function IsPrecedenceAnd(pattern) {
+        for (let index = 0; index < pattern.length; index++) {
+          if (IsOpenParen(pattern, index))
+            return true;
+        }
+        return false;
+      }
+      function Or(pattern) {
+        let [count, start] = [0, 0];
+        const expressions = [];
+        for (let index = 0; index < pattern.length; index++) {
+          if (IsOpenParen(pattern, index))
+            count += 1;
+          if (IsCloseParen(pattern, index))
+            count -= 1;
+          if (IsSeparator(pattern, index) && count === 0) {
+            const range2 = pattern.slice(start, index);
+            if (range2.length > 0)
+              expressions.push(Parse(range2));
+            start = index + 1;
+          }
+        }
+        const range = pattern.slice(start);
+        if (range.length > 0)
+          expressions.push(Parse(range));
+        if (expressions.length === 0)
+          return { type: "const", const: "" };
+        if (expressions.length === 1)
+          return expressions[0];
+        return { type: "or", expr: expressions };
+      }
+      function And(pattern) {
+        function Group(value, index) {
+          if (!IsOpenParen(value, index))
+            throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
+          let count = 0;
+          for (let scan = index; scan < value.length; scan++) {
+            if (IsOpenParen(value, scan))
+              count += 1;
+            if (IsCloseParen(value, scan))
+              count -= 1;
+            if (count === 0)
+              return [index, scan];
+          }
+          throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
+        }
+        function Range(pattern2, index) {
+          for (let scan = index; scan < pattern2.length; scan++) {
+            if (IsOpenParen(pattern2, scan))
+              return [index, scan];
+          }
+          return [index, pattern2.length];
+        }
+        const expressions = [];
+        for (let index = 0; index < pattern.length; index++) {
+          if (IsOpenParen(pattern, index)) {
+            const [start, end] = Group(pattern, index);
+            const range = pattern.slice(start, end + 1);
+            expressions.push(Parse(range));
+            index = end;
+          } else {
+            const [start, end] = Range(pattern, index);
+            const range = pattern.slice(start, end);
+            if (range.length > 0)
+              expressions.push(Parse(range));
+            index = end - 1;
+          }
+        }
+        return expressions.length === 0 ? { type: "const", const: "" } : expressions.length === 1 ? expressions[0] : { type: "and", expr: expressions };
+      }
+      function Parse(pattern) {
+        return IsGroup(pattern) ? Parse(InGroup(pattern)) : IsPrecedenceOr(pattern) ? Or(pattern) : IsPrecedenceAnd(pattern) ? And(pattern) : { type: "const", const: pattern };
+      }
+      TemplateLiteralParser2.Parse = Parse;
+      function ParseExact(pattern) {
+        return Parse(pattern.slice(1, pattern.length - 1));
+      }
+      TemplateLiteralParser2.ParseExact = ParseExact;
+    })(TemplateLiteralParser || (exports.TemplateLiteralParser = TemplateLiteralParser = {}));
+    var TemplateLiteralFiniteError = class extends TypeBoxError {
+    };
+    exports.TemplateLiteralFiniteError = TemplateLiteralFiniteError;
+    var TemplateLiteralFinite;
+    (function(TemplateLiteralFinite2) {
+      function Throw(message) {
+        throw new TemplateLiteralFiniteError(message);
+      }
+      function IsNumber(expression) {
+        return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "0" && expression.expr[1].type === "const" && expression.expr[1].const === "[1-9][0-9]*";
+      }
+      function IsBoolean(expression) {
+        return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "true" && expression.expr[1].type === "const" && expression.expr[1].const === "false";
+      }
+      function IsString(expression) {
+        return expression.type === "const" && expression.const === ".*";
+      }
+      function Check(expression) {
+        return IsBoolean(expression) ? true : IsNumber(expression) || IsString(expression) ? false : expression.type === "and" ? expression.expr.every((expr) => Check(expr)) : expression.type === "or" ? expression.expr.every((expr) => Check(expr)) : expression.type === "const" ? true : Throw(`Unknown expression type`);
+      }
+      TemplateLiteralFinite2.Check = Check;
+    })(TemplateLiteralFinite || (exports.TemplateLiteralFinite = TemplateLiteralFinite = {}));
+    var TemplateLiteralGeneratorError = class extends TypeBoxError {
+    };
+    exports.TemplateLiteralGeneratorError = TemplateLiteralGeneratorError;
+    var TemplateLiteralGenerator;
+    (function(TemplateLiteralGenerator2) {
+      function* Reduce(buffer) {
+        if (buffer.length === 1)
+          return yield* buffer[0];
+        for (const left of buffer[0]) {
+          for (const right of Reduce(buffer.slice(1))) {
+            yield `${left}${right}`;
+          }
+        }
+      }
+      function* And(expression) {
+        return yield* Reduce(expression.expr.map((expr) => [...Generate(expr)]));
+      }
+      function* Or(expression) {
+        for (const expr of expression.expr)
+          yield* Generate(expr);
+      }
+      function* Const(expression) {
+        return yield expression.const;
+      }
+      function* Generate(expression) {
+        return expression.type === "and" ? yield* And(expression) : expression.type === "or" ? yield* Or(expression) : expression.type === "const" ? yield* Const(expression) : (() => {
+          throw new TemplateLiteralGeneratorError("Unknown expression");
+        })();
+      }
+      TemplateLiteralGenerator2.Generate = Generate;
+    })(TemplateLiteralGenerator || (exports.TemplateLiteralGenerator = TemplateLiteralGenerator = {}));
+    var TemplateLiteralDslParser;
+    (function(TemplateLiteralDslParser2) {
+      function* ParseUnion(template) {
+        const trim = template.trim().replace(/"|'/g, "");
+        return trim === "boolean" ? yield exports.Type.Boolean() : trim === "number" ? yield exports.Type.Number() : trim === "bigint" ? yield exports.Type.BigInt() : trim === "string" ? yield exports.Type.String() : yield (() => {
+          const literals = trim.split("|").map((literal) => exports.Type.Literal(literal.trim()));
+          return literals.length === 0 ? exports.Type.Never() : literals.length === 1 ? literals[0] : exports.Type.Union(literals);
+        })();
+      }
+      function* ParseTerminal(template) {
+        if (template[1] !== "{") {
+          const L = exports.Type.Literal("$");
+          const R = ParseLiteral(template.slice(1));
+          return yield* [L, ...R];
+        }
+        for (let i = 2; i < template.length; i++) {
+          if (template[i] === "}") {
+            const L = ParseUnion(template.slice(2, i));
+            const R = ParseLiteral(template.slice(i + 1));
+            return yield* [...L, ...R];
+          }
+        }
+        yield exports.Type.Literal(template);
+      }
+      function* ParseLiteral(template) {
+        for (let i = 0; i < template.length; i++) {
+          if (template[i] === "$") {
+            const L = exports.Type.Literal(template.slice(0, i));
+            const R = ParseTerminal(template.slice(i));
+            return yield* [L, ...R];
+          }
+        }
+        yield exports.Type.Literal(template);
+      }
+      function Parse(template_dsl) {
+        return [...ParseLiteral(template_dsl)];
+      }
+      TemplateLiteralDslParser2.Parse = Parse;
+    })(TemplateLiteralDslParser || (exports.TemplateLiteralDslParser = TemplateLiteralDslParser = {}));
+    var TransformDecodeBuilder = class {
+      constructor(schema) {
+        this.schema = schema;
+      }
+      Decode(decode) {
+        return new TransformEncodeBuilder(this.schema, decode);
+      }
+    };
+    exports.TransformDecodeBuilder = TransformDecodeBuilder;
+    var TransformEncodeBuilder = class {
+      constructor(schema, decode) {
+        this.schema = schema;
+        this.decode = decode;
+      }
+      Encode(encode) {
+        const schema = TypeClone.Type(this.schema);
+        return TypeGuard.TTransform(schema) ? (() => {
+          const Encode = (value) => schema[exports.Transform].Encode(encode(value));
+          const Decode = (value) => this.decode(schema[exports.Transform].Decode(value));
+          const Codec = { Encode, Decode };
+          return { ...schema, [exports.Transform]: Codec };
+        })() : (() => {
+          const Codec = { Decode: this.decode, Encode: encode };
+          return { ...schema, [exports.Transform]: Codec };
+        })();
+      }
+    };
+    exports.TransformEncodeBuilder = TransformEncodeBuilder;
+    var TypeOrdinal = 0;
+    var TypeBuilderError = class extends TypeBoxError {
+    };
+    exports.TypeBuilderError = TypeBuilderError;
+    var TypeBuilder = class {
+      /** `[Internal]` Creates a schema without `static` and `params` types */
+      Create(schema) {
+        return schema;
+      }
+      /** `[Internal]` Throws a TypeBuilder error with the given message */
+      Throw(message) {
+        throw new TypeBuilderError(message);
+      }
+      /** `[Internal]` Discards property keys from the given record type */
+      Discard(record, keys) {
+        return keys.reduce((acc, key) => {
+          const { [key]: _, ...rest } = acc;
+          return rest;
+        }, record);
+      }
+      /** `[Json]` Omits compositing symbols from this schema */
+      Strict(schema) {
+        return JSON.parse(JSON.stringify(schema));
+      }
+    };
+    exports.TypeBuilder = TypeBuilder;
+    var JsonTypeBuilder = class extends TypeBuilder {
+      // ------------------------------------------------------------------------
+      // Modifiers
+      // ------------------------------------------------------------------------
+      /** `[Json]` Creates a Readonly and Optional property */
+      ReadonlyOptional(schema) {
+        return this.Readonly(this.Optional(schema));
+      }
+      /** `[Json]` Creates a Readonly property */
+      Readonly(schema) {
+        return { ...TypeClone.Type(schema), [exports.Readonly]: "Readonly" };
+      }
+      /** `[Json]` Creates an Optional property */
+      Optional(schema) {
+        return { ...TypeClone.Type(schema), [exports.Optional]: "Optional" };
+      }
+      // ------------------------------------------------------------------------
+      // Types
+      // ------------------------------------------------------------------------
+      /** `[Json]` Creates an Any type */
+      Any(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Any" });
+      }
+      /** `[Json]` Creates an Array type */
+      Array(schema, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Array", type: "array", items: TypeClone.Type(schema) });
+      }
+      /** `[Json]` Creates a Boolean type */
+      Boolean(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Boolean", type: "boolean" });
+      }
+      /** `[Json]` Intrinsic function to Capitalize LiteralString types */
+      Capitalize(schema, options = {}) {
+        return { ...Intrinsic.Map(TypeClone.Type(schema), "Capitalize"), ...options };
+      }
+      /** `[Json]` Creates a Composite object type */
+      Composite(objects, options) {
+        const intersect = exports.Type.Intersect(objects, {});
+        const keys = KeyResolver.ResolveKeys(intersect, { includePatterns: false });
+        const properties = keys.reduce((acc, key) => ({ ...acc, [key]: exports.Type.Index(intersect, [key]) }), {});
+        return exports.Type.Object(properties, options);
+      }
+      /** `[Json]` Creates a Enum type */
+      Enum(item, options = {}) {
+        if (ValueGuard.IsUndefined(item))
+          return this.Throw("Enum undefined or empty");
+        const values1 = Object.getOwnPropertyNames(item).filter((key) => isNaN(key)).map((key) => item[key]);
+        const values2 = [...new Set(values1)];
+        const anyOf = values2.map((value) => exports.Type.Literal(value));
+        return this.Union(anyOf, { ...options, [exports.Hint]: "Enum" });
+      }
+      /** `[Json]` Creates a Conditional type */
+      Extends(left, right, trueType, falseType, options = {}) {
+        switch (TypeExtends.Extends(left, right)) {
+          case TypeExtendsResult.Union:
+            return this.Union([TypeClone.Type(trueType, options), TypeClone.Type(falseType, options)]);
+          case TypeExtendsResult.True:
+            return TypeClone.Type(trueType, options);
+          case TypeExtendsResult.False:
+            return TypeClone.Type(falseType, options);
+        }
+      }
+      /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+      Exclude(unionType, excludedMembers, options = {}) {
+        return TypeGuard.TTemplateLiteral(unionType) ? this.Exclude(TemplateLiteralResolver.Resolve(unionType), excludedMembers, options) : TypeGuard.TTemplateLiteral(excludedMembers) ? this.Exclude(unionType, TemplateLiteralResolver.Resolve(excludedMembers), options) : TypeGuard.TUnion(unionType) ? (() => {
+          const narrowed = unionType.anyOf.filter((inner) => TypeExtends.Extends(inner, excludedMembers) === TypeExtendsResult.False);
+          return narrowed.length === 1 ? TypeClone.Type(narrowed[0], options) : this.Union(narrowed, options);
+        })() : TypeExtends.Extends(unionType, excludedMembers) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Type(unionType, options);
+      }
+      /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+      Extract(type, union, options = {}) {
+        return TypeGuard.TTemplateLiteral(type) ? this.Extract(TemplateLiteralResolver.Resolve(type), union, options) : TypeGuard.TTemplateLiteral(union) ? this.Extract(type, TemplateLiteralResolver.Resolve(union), options) : TypeGuard.TUnion(type) ? (() => {
+          const narrowed = type.anyOf.filter((inner) => TypeExtends.Extends(inner, union) !== TypeExtendsResult.False);
+          return narrowed.length === 1 ? TypeClone.Type(narrowed[0], options) : this.Union(narrowed, options);
+        })() : TypeExtends.Extends(type, union) !== TypeExtendsResult.False ? TypeClone.Type(type, options) : this.Never(options);
+      }
+      /** `[Json]` Returns an Indexed property type for the given keys */
+      Index(schema, unresolved, options = {}) {
+        return TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved) ? (() => {
+          return TypeClone.Type(schema.items, options);
+        })() : TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved) ? (() => {
+          const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items;
+          const cloned = items.map((schema2) => TypeClone.Type(schema2));
+          return this.Union(cloned, options);
+        })() : (() => {
+          const keys = KeyArrayResolver.Resolve(unresolved);
+          const clone = TypeClone.Type(schema);
+          return IndexedAccessor.Resolve(clone, keys, options);
+        })();
+      }
+      /** `[Json]` Creates an Integer type */
+      Integer(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Integer", type: "integer" });
+      }
+      /** `[Json]` Creates an Intersect type */
+      Intersect(allOf, options = {}) {
+        if (allOf.length === 0)
+          return exports.Type.Never();
+        if (allOf.length === 1)
+          return TypeClone.Type(allOf[0], options);
+        if (allOf.some((schema) => TypeGuard.TTransform(schema)))
+          this.Throw("Cannot intersect transform types");
+        const objects = allOf.every((schema) => TypeGuard.TObject(schema));
+        const cloned = TypeClone.Rest(allOf);
+        const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties) ? { unevaluatedProperties: TypeClone.Type(options.unevaluatedProperties) } : {};
+        return options.unevaluatedProperties === false || TypeGuard.TSchema(options.unevaluatedProperties) || objects ? this.Create({ ...options, ...clonedUnevaluatedProperties, [exports.Kind]: "Intersect", type: "object", allOf: cloned }) : this.Create({ ...options, ...clonedUnevaluatedProperties, [exports.Kind]: "Intersect", allOf: cloned });
+      }
+      /** `[Json]` Creates a KeyOf type */
+      KeyOf(schema, options = {}) {
+        return TypeGuard.TRecord(schema) ? (() => {
+          const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+          return pattern === exports.PatternNumberExact ? this.Number(options) : pattern === exports.PatternStringExact ? this.String(options) : this.Throw("Unable to resolve key type from Record key pattern");
+        })() : TypeGuard.TTuple(schema) ? (() => {
+          const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items;
+          const literals = items.map((_, index) => exports.Type.Literal(index.toString()));
+          return this.Union(literals, options);
+        })() : TypeGuard.TArray(schema) ? (() => {
+          return this.Number(options);
+        })() : (() => {
+          const keys = KeyResolver.ResolveKeys(schema, { includePatterns: false });
+          if (keys.length === 0)
+            return this.Never(options);
+          const literals = keys.map((key) => this.Literal(key));
+          return this.Union(literals, options);
+        })();
+      }
+      /** `[Json]` Creates a Literal type */
+      Literal(value, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Literal", const: value, type: typeof value });
+      }
+      /** `[Json]` Intrinsic function to Lowercase LiteralString types */
+      Lowercase(schema, options = {}) {
+        return { ...Intrinsic.Map(TypeClone.Type(schema), "Lowercase"), ...options };
+      }
+      /** `[Json]` Creates a Never type */
+      Never(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Never", not: {} });
+      }
+      /** `[Json]` Creates a Not type */
+      Not(schema, options) {
+        return this.Create({ ...options, [exports.Kind]: "Not", not: TypeClone.Type(schema) });
+      }
+      /** `[Json]` Creates a Null type */
+      Null(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Null", type: "null" });
+      }
+      /** `[Json]` Creates a Number type */
+      Number(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Number", type: "number" });
+      }
+      /** `[Json]` Creates an Object type */
+      Object(properties, options = {}) {
+        const propertyKeys = Object.getOwnPropertyNames(properties);
+        const optionalKeys = propertyKeys.filter((key) => TypeGuard.TOptional(properties[key]));
+        const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
+        const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Type(options.additionalProperties) } : {};
+        const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Type(properties[key]) }), {});
+        return requiredKeys.length > 0 ? this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: "Object", type: "object", properties: clonedProperties, required: requiredKeys }) : this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: "Object", type: "object", properties: clonedProperties });
+      }
+      /** `[Json]` Constructs a type whose keys are omitted from the given type */
+      Omit(schema, unresolved, options = {}) {
+        const keys = KeyArrayResolver.Resolve(unresolved);
+        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ["$id", exports.Transform]), (object) => {
+          if (ValueGuard.IsArray(object.required)) {
+            object.required = object.required.filter((key) => !keys.includes(key));
+            if (object.required.length === 0)
+              delete object.required;
+          }
+          for (const key of Object.getOwnPropertyNames(object.properties)) {
+            if (keys.includes(key))
+              delete object.properties[key];
+          }
+          return this.Create(object);
+        }, options);
+      }
+      /** `[Json]` Constructs a type where all properties are optional */
+      Partial(schema, options = {}) {
+        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ["$id", exports.Transform]), (object) => {
+          const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
+            return { ...acc, [key]: this.Optional(object.properties[key]) };
+          }, {});
+          return this.Object(
+            properties,
+            this.Discard(object, ["required"])
+            /* object used as options to retain other constraints */
+          );
+        }, options);
+      }
+      /** `[Json]` Constructs a type whose keys are picked from the given type */
+      Pick(schema, unresolved, options = {}) {
+        const keys = KeyArrayResolver.Resolve(unresolved);
+        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ["$id", exports.Transform]), (object) => {
+          if (ValueGuard.IsArray(object.required)) {
+            object.required = object.required.filter((key) => keys.includes(key));
+            if (object.required.length === 0)
+              delete object.required;
+          }
+          for (const key of Object.getOwnPropertyNames(object.properties)) {
+            if (!keys.includes(key))
+              delete object.properties[key];
+          }
+          return this.Create(object);
+        }, options);
+      }
+      /** `[Json]` Creates a Record type */
+      Record(key, schema, options = {}) {
+        return TypeGuard.TTemplateLiteral(key) ? (() => {
+          const expression = TemplateLiteralParser.ParseExact(key.pattern);
+          return TemplateLiteralFinite.Check(expression) ? this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key2) => ({ ...acc, [key2]: TypeClone.Type(schema) }), {}), options) : this.Create({ ...options, [exports.Kind]: "Record", type: "object", patternProperties: { [key.pattern]: TypeClone.Type(schema) } });
+        })() : TypeGuard.TUnion(key) ? (() => {
+          const union = UnionResolver.Resolve(key);
+          if (TypeGuard.TUnionLiteral(union)) {
+            const properties = union.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Type(schema) }), {});
+            return this.Object(properties, { ...options, [exports.Hint]: "Record" });
+          } else
+            this.Throw("Record key of type union contains non-literal types");
+        })() : TypeGuard.TLiteral(key) ? (() => {
+          return ValueGuard.IsString(key.const) || ValueGuard.IsNumber(key.const) ? this.Object({ [key.const]: TypeClone.Type(schema) }, options) : this.Throw("Record key of type literal is not of type string or number");
+        })() : TypeGuard.TInteger(key) || TypeGuard.TNumber(key) ? (() => {
+          return this.Create({ ...options, [exports.Kind]: "Record", type: "object", patternProperties: { [exports.PatternNumberExact]: TypeClone.Type(schema) } });
+        })() : TypeGuard.TString(key) ? (() => {
+          const pattern = ValueGuard.IsUndefined(key.pattern) ? exports.PatternStringExact : key.pattern;
+          return this.Create({ ...options, [exports.Kind]: "Record", type: "object", patternProperties: { [pattern]: TypeClone.Type(schema) } });
+        })() : this.Never();
+      }
+      /** `[Json]` Creates a Recursive type */
+      Recursive(callback, options = {}) {
+        if (ValueGuard.IsUndefined(options.$id))
+          options.$id = `T${TypeOrdinal++}`;
+        const thisType = callback({ [exports.Kind]: "This", $ref: `${options.$id}` });
+        thisType.$id = options.$id;
+        return this.Create({ ...options, [exports.Hint]: "Recursive", ...thisType });
+      }
+      /** `[Json]` Creates a Ref type. */
+      Ref(unresolved, options = {}) {
+        if (ValueGuard.IsString(unresolved))
+          return this.Create({ ...options, [exports.Kind]: "Ref", $ref: unresolved });
+        if (ValueGuard.IsUndefined(unresolved.$id))
+          this.Throw("Reference target type must specify an $id");
+        return this.Create({ ...options, [exports.Kind]: "Ref", $ref: unresolved.$id });
+      }
+      /** `[Json]` Constructs a type where all properties are required */
+      Required(schema, options = {}) {
+        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ["$id", exports.Transform]), (object) => {
+          const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
+            return { ...acc, [key]: this.Discard(object.properties[key], [exports.Optional]) };
+          }, {});
+          return this.Object(
+            properties,
+            object
+            /* object used as options to retain other constraints  */
+          );
+        }, options);
+      }
+      /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
+      Rest(schema) {
+        return TypeGuard.TTuple(schema) && !ValueGuard.IsUndefined(schema.items) ? TypeClone.Rest(schema.items) : TypeGuard.TIntersect(schema) ? TypeClone.Rest(schema.allOf) : TypeGuard.TUnion(schema) ? TypeClone.Rest(schema.anyOf) : [];
+      }
+      /** `[Json]` Creates a String type */
+      String(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "String", type: "string" });
+      }
+      /** `[Json]` Creates a TemplateLiteral type */
+      TemplateLiteral(unresolved, options = {}) {
+        const pattern = ValueGuard.IsString(unresolved) ? TemplateLiteralPattern.Create(TemplateLiteralDslParser.Parse(unresolved)) : TemplateLiteralPattern.Create(unresolved);
+        return this.Create({ ...options, [exports.Kind]: "TemplateLiteral", type: "string", pattern });
+      }
+      /** `[Json]` Creates a Transform type */
+      Transform(schema) {
+        return new TransformDecodeBuilder(schema);
+      }
+      /** `[Json]` Creates a Tuple type */
+      Tuple(items, options = {}) {
+        const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
+        const clonedItems = TypeClone.Rest(items);
+        const schema = items.length > 0 ? { ...options, [exports.Kind]: "Tuple", type: "array", items: clonedItems, additionalItems, minItems, maxItems } : { ...options, [exports.Kind]: "Tuple", type: "array", minItems, maxItems };
+        return this.Create(schema);
+      }
+      /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
+      Uncapitalize(schema, options = {}) {
+        return { ...Intrinsic.Map(TypeClone.Type(schema), "Uncapitalize"), ...options };
+      }
+      /** `[Json]` Creates a Union type */
+      Union(union, options = {}) {
+        return TypeGuard.TTemplateLiteral(union) ? TemplateLiteralResolver.Resolve(union) : (() => {
+          const anyOf = union;
+          if (anyOf.length === 0)
+            return this.Never(options);
+          if (anyOf.length === 1)
+            return this.Create(TypeClone.Type(anyOf[0], options));
+          const clonedAnyOf = TypeClone.Rest(anyOf);
+          return this.Create({ ...options, [exports.Kind]: "Union", anyOf: clonedAnyOf });
+        })();
+      }
+      /** `[Json]` Creates an Unknown type */
+      Unknown(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Unknown" });
+      }
+      /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
+      Unsafe(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: options[exports.Kind] || "Unsafe" });
+      }
+      /** `[Json]` Intrinsic function to Uppercase LiteralString types */
+      Uppercase(schema, options = {}) {
+        return { ...Intrinsic.Map(TypeClone.Type(schema), "Uppercase"), ...options };
+      }
+    };
+    exports.JsonTypeBuilder = JsonTypeBuilder;
+    var JavaScriptTypeBuilder = class extends JsonTypeBuilder {
+      /** `[JavaScript]` Creates a AsyncIterator type */
+      AsyncIterator(items, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "AsyncIterator", type: "AsyncIterator", items: TypeClone.Type(items) });
+      }
+      /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
+      Awaited(schema, options = {}) {
+        const Unwrap = (rest) => rest.length > 0 ? (() => {
+          const [L, ...R] = rest;
+          return [this.Awaited(L), ...Unwrap(R)];
+        })() : rest;
+        return TypeGuard.TIntersect(schema) ? exports.Type.Intersect(Unwrap(schema.allOf)) : TypeGuard.TUnion(schema) ? exports.Type.Union(Unwrap(schema.anyOf)) : TypeGuard.TPromise(schema) ? this.Awaited(schema.item) : TypeClone.Type(schema, options);
+      }
+      /** `[JavaScript]` Creates a BigInt type */
+      BigInt(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "BigInt", type: "bigint" });
+      }
+      /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
+      ConstructorParameters(schema, options = {}) {
+        return this.Tuple([...schema.parameters], { ...options });
+      }
+      /** `[JavaScript]` Creates a Constructor type */
+      Constructor(parameters, returns, options) {
+        const [clonedParameters, clonedReturns] = [TypeClone.Rest(parameters), TypeClone.Type(returns)];
+        return this.Create({ ...options, [exports.Kind]: "Constructor", type: "Constructor", parameters: clonedParameters, returns: clonedReturns });
+      }
+      /** `[JavaScript]` Creates a Date type */
+      Date(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Date", type: "Date" });
+      }
+      /** `[JavaScript]` Creates a Function type */
+      Function(parameters, returns, options) {
+        const [clonedParameters, clonedReturns] = [TypeClone.Rest(parameters), TypeClone.Type(returns)];
+        return this.Create({ ...options, [exports.Kind]: "Function", type: "Function", parameters: clonedParameters, returns: clonedReturns });
+      }
+      /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
+      InstanceType(schema, options = {}) {
+        return TypeClone.Type(schema.returns, options);
+      }
+      /** `[JavaScript]` Creates an Iterator type */
+      Iterator(items, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Iterator", type: "Iterator", items: TypeClone.Type(items) });
+      }
+      /** `[JavaScript]` Extracts the Parameters from the given Function type */
+      Parameters(schema, options = {}) {
+        return this.Tuple(schema.parameters, { ...options });
+      }
+      /** `[JavaScript]` Creates a Promise type */
+      Promise(item, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Promise", type: "Promise", item: TypeClone.Type(item) });
+      }
+      /** `[Extended]` Creates a String type */
+      RegExp(unresolved, options = {}) {
+        const pattern = ValueGuard.IsString(unresolved) ? unresolved : unresolved.source;
+        return this.Create({ ...options, [exports.Kind]: "String", type: "string", pattern });
+      }
+      /**
+       * @deprecated Use `Type.RegExp`
+       */
+      RegEx(regex, options = {}) {
+        return this.RegExp(regex, options);
+      }
+      /** `[JavaScript]` Extracts the ReturnType from the given Function type */
+      ReturnType(schema, options = {}) {
+        return TypeClone.Type(schema.returns, options);
+      }
+      /** `[JavaScript]` Creates a Symbol type */
+      Symbol(options) {
+        return this.Create({ ...options, [exports.Kind]: "Symbol", type: "symbol" });
+      }
+      /** `[JavaScript]` Creates a Undefined type */
+      Undefined(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Undefined", type: "undefined" });
+      }
+      /** `[JavaScript]` Creates a Uint8Array type */
+      Uint8Array(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Uint8Array", type: "Uint8Array" });
+      }
+      /** `[JavaScript]` Creates a Void type */
+      Void(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Void", type: "void" });
+      }
+    };
+    exports.JavaScriptTypeBuilder = JavaScriptTypeBuilder;
+    exports.JsonType = new JsonTypeBuilder();
+    exports.Type = new JavaScriptTypeBuilder();
+  }
+});
+
+// node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
+var __assign = function() {
+  __assign = Object.assign || function __assign2(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+
+// node_modules/.pnpm/@formatjs+icu-messageformat-parser@2.11.4/node_modules/@formatjs/icu-messageformat-parser/lib/error.js
+var ErrorKind;
+(function(ErrorKind2) {
+  ErrorKind2[ErrorKind2["EXPECT_ARGUMENT_CLOSING_BRACE"] = 1] = "EXPECT_ARGUMENT_CLOSING_BRACE";
+  ErrorKind2[ErrorKind2["EMPTY_ARGUMENT"] = 2] = "EMPTY_ARGUMENT";
+  ErrorKind2[ErrorKind2["MALFORMED_ARGUMENT"] = 3] = "MALFORMED_ARGUMENT";
+  ErrorKind2[ErrorKind2["EXPECT_ARGUMENT_TYPE"] = 4] = "EXPECT_ARGUMENT_TYPE";
+  ErrorKind2[ErrorKind2["INVALID_ARGUMENT_TYPE"] = 5] = "INVALID_ARGUMENT_TYPE";
+  ErrorKind2[ErrorKind2["EXPECT_ARGUMENT_STYLE"] = 6] = "EXPECT_ARGUMENT_STYLE";
+  ErrorKind2[ErrorKind2["INVALID_NUMBER_SKELETON"] = 7] = "INVALID_NUMBER_SKELETON";
+  ErrorKind2[ErrorKind2["INVALID_DATE_TIME_SKELETON"] = 8] = "INVALID_DATE_TIME_SKELETON";
+  ErrorKind2[ErrorKind2["EXPECT_NUMBER_SKELETON"] = 9] = "EXPECT_NUMBER_SKELETON";
+  ErrorKind2[ErrorKind2["EXPECT_DATE_TIME_SKELETON"] = 10] = "EXPECT_DATE_TIME_SKELETON";
+  ErrorKind2[ErrorKind2["UNCLOSED_QUOTE_IN_ARGUMENT_STYLE"] = 11] = "UNCLOSED_QUOTE_IN_ARGUMENT_STYLE";
+  ErrorKind2[ErrorKind2["EXPECT_SELECT_ARGUMENT_OPTIONS"] = 12] = "EXPECT_SELECT_ARGUMENT_OPTIONS";
+  ErrorKind2[ErrorKind2["EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE"] = 13] = "EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE";
+  ErrorKind2[ErrorKind2["INVALID_PLURAL_ARGUMENT_OFFSET_VALUE"] = 14] = "INVALID_PLURAL_ARGUMENT_OFFSET_VALUE";
+  ErrorKind2[ErrorKind2["EXPECT_SELECT_ARGUMENT_SELECTOR"] = 15] = "EXPECT_SELECT_ARGUMENT_SELECTOR";
+  ErrorKind2[ErrorKind2["EXPECT_PLURAL_ARGUMENT_SELECTOR"] = 16] = "EXPECT_PLURAL_ARGUMENT_SELECTOR";
+  ErrorKind2[ErrorKind2["EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT"] = 17] = "EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT";
+  ErrorKind2[ErrorKind2["EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT"] = 18] = "EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT";
+  ErrorKind2[ErrorKind2["INVALID_PLURAL_ARGUMENT_SELECTOR"] = 19] = "INVALID_PLURAL_ARGUMENT_SELECTOR";
+  ErrorKind2[ErrorKind2["DUPLICATE_PLURAL_ARGUMENT_SELECTOR"] = 20] = "DUPLICATE_PLURAL_ARGUMENT_SELECTOR";
+  ErrorKind2[ErrorKind2["DUPLICATE_SELECT_ARGUMENT_SELECTOR"] = 21] = "DUPLICATE_SELECT_ARGUMENT_SELECTOR";
+  ErrorKind2[ErrorKind2["MISSING_OTHER_CLAUSE"] = 22] = "MISSING_OTHER_CLAUSE";
+  ErrorKind2[ErrorKind2["INVALID_TAG"] = 23] = "INVALID_TAG";
+  ErrorKind2[ErrorKind2["INVALID_TAG_NAME"] = 25] = "INVALID_TAG_NAME";
+  ErrorKind2[ErrorKind2["UNMATCHED_CLOSING_TAG"] = 26] = "UNMATCHED_CLOSING_TAG";
+  ErrorKind2[ErrorKind2["UNCLOSED_TAG"] = 27] = "UNCLOSED_TAG";
+})(ErrorKind || (ErrorKind = {}));
+
+// node_modules/.pnpm/@formatjs+icu-messageformat-parser@2.11.4/node_modules/@formatjs/icu-messageformat-parser/lib/types.js
+var TYPE;
+(function(TYPE2) {
+  TYPE2[TYPE2["literal"] = 0] = "literal";
+  TYPE2[TYPE2["argument"] = 1] = "argument";
+  TYPE2[TYPE2["number"] = 2] = "number";
+  TYPE2[TYPE2["date"] = 3] = "date";
+  TYPE2[TYPE2["time"] = 4] = "time";
+  TYPE2[TYPE2["select"] = 5] = "select";
+  TYPE2[TYPE2["plural"] = 6] = "plural";
+  TYPE2[TYPE2["pound"] = 7] = "pound";
+  TYPE2[TYPE2["tag"] = 8] = "tag";
+})(TYPE || (TYPE = {}));
+var SKELETON_TYPE;
+(function(SKELETON_TYPE2) {
+  SKELETON_TYPE2[SKELETON_TYPE2["number"] = 0] = "number";
+  SKELETON_TYPE2[SKELETON_TYPE2["dateTime"] = 1] = "dateTime";
+})(SKELETON_TYPE || (SKELETON_TYPE = {}));
+function isNumberElement(el) {
+  return el.type === TYPE.number;
+}
+function isDateElement(el) {
+  return el.type === TYPE.date;
+}
+function isTimeElement(el) {
+  return el.type === TYPE.time;
+}
+function isSelectElement(el) {
+  return el.type === TYPE.select;
+}
+function isPluralElement(el) {
+  return el.type === TYPE.plural;
+}
+function isTagElement(el) {
+  return el.type === TYPE.tag;
+}
+function isNumberSkeleton(el) {
+  return !!(el && typeof el === "object" && el.type === SKELETON_TYPE.number);
+}
+function isDateTimeSkeleton(el) {
+  return !!(el && typeof el === "object" && el.type === SKELETON_TYPE.dateTime);
+}
+
+// node_modules/.pnpm/@formatjs+icu-messageformat-parser@2.11.4/node_modules/@formatjs/icu-messageformat-parser/lib/regex.generated.js
+var SPACE_SEPARATOR_REGEX = /[ \xA0\u1680\u2000-\u200A\u202F\u205F\u3000]/;
+
+// node_modules/.pnpm/@formatjs+icu-skeleton-parser@1.8.16/node_modules/@formatjs/icu-skeleton-parser/lib/date-time.js
+var DATE_TIME_REGEX = /(?:[Eec]{1,6}|G{1,5}|[Qq]{1,5}|(?:[yYur]+|U{1,5})|[ML]{1,5}|d{1,2}|D{1,3}|F{1}|[abB]{1,5}|[hkHK]{1,2}|w{1,2}|W{1}|m{1,2}|s{1,2}|[zZOvVxX]{1,4})(?=([^']*'[^']*')*[^']*$)/g;
+function parseDateTimeSkeleton(skeleton) {
+  var result = {};
+  skeleton.replace(DATE_TIME_REGEX, function(match) {
+    var len = match.length;
+    switch (match[0]) {
+      // Era
+      case "G":
+        result.era = len === 4 ? "long" : len === 5 ? "narrow" : "short";
+        break;
+      // Year
+      case "y":
+        result.year = len === 2 ? "2-digit" : "numeric";
+        break;
+      case "Y":
+      case "u":
+      case "U":
+      case "r":
+        throw new RangeError("`Y/u/U/r` (year) patterns are not supported, use `y` instead");
+      // Quarter
+      case "q":
+      case "Q":
+        throw new RangeError("`q/Q` (quarter) patterns are not supported");
+      // Month
+      case "M":
+      case "L":
+        result.month = ["numeric", "2-digit", "short", "long", "narrow"][len - 1];
+        break;
+      // Week
+      case "w":
+      case "W":
+        throw new RangeError("`w/W` (week) patterns are not supported");
+      case "d":
+        result.day = ["numeric", "2-digit"][len - 1];
+        break;
+      case "D":
+      case "F":
+      case "g":
+        throw new RangeError("`D/F/g` (day) patterns are not supported, use `d` instead");
+      // Weekday
+      case "E":
+        result.weekday = len === 4 ? "long" : len === 5 ? "narrow" : "short";
+        break;
+      case "e":
+        if (len < 4) {
+          throw new RangeError("`e..eee` (weekday) patterns are not supported");
+        }
+        result.weekday = ["short", "long", "narrow", "short"][len - 4];
+        break;
+      case "c":
+        if (len < 4) {
+          throw new RangeError("`c..ccc` (weekday) patterns are not supported");
+        }
+        result.weekday = ["short", "long", "narrow", "short"][len - 4];
+        break;
+      // Period
+      case "a":
+        result.hour12 = true;
+        break;
+      case "b":
+      // am, pm, noon, midnight
+      case "B":
+        throw new RangeError("`b/B` (period) patterns are not supported, use `a` instead");
+      // Hour
+      case "h":
+        result.hourCycle = "h12";
+        result.hour = ["numeric", "2-digit"][len - 1];
+        break;
+      case "H":
+        result.hourCycle = "h23";
+        result.hour = ["numeric", "2-digit"][len - 1];
+        break;
+      case "K":
+        result.hourCycle = "h11";
+        result.hour = ["numeric", "2-digit"][len - 1];
+        break;
+      case "k":
+        result.hourCycle = "h24";
+        result.hour = ["numeric", "2-digit"][len - 1];
+        break;
+      case "j":
+      case "J":
+      case "C":
+        throw new RangeError("`j/J/C` (hour) patterns are not supported, use `h/H/K/k` instead");
+      // Minute
+      case "m":
+        result.minute = ["numeric", "2-digit"][len - 1];
+        break;
+      // Second
+      case "s":
+        result.second = ["numeric", "2-digit"][len - 1];
+        break;
+      case "S":
+      case "A":
+        throw new RangeError("`S/A` (second) patterns are not supported, use `s` instead");
+      // Zone
+      case "z":
+        result.timeZoneName = len < 4 ? "short" : "long";
+        break;
+      case "Z":
+      // 1..3, 4, 5: The ISO8601 varios formats
+      case "O":
+      // 1, 4: milliseconds in day short, long
+      case "v":
+      // 1, 4: generic non-location format
+      case "V":
+      // 1, 2, 3, 4: time zone ID or city
+      case "X":
+      // 1, 2, 3, 4: The ISO8601 varios formats
+      case "x":
+        throw new RangeError("`Z/O/v/V/X/x` (timeZone) patterns are not supported, use `z` instead");
+    }
+    return "";
+  });
+  return result;
+}
+
+// node_modules/.pnpm/@formatjs+icu-skeleton-parser@1.8.16/node_modules/@formatjs/icu-skeleton-parser/lib/regex.generated.js
+var WHITE_SPACE_REGEX = /[\t-\r \x85\u200E\u200F\u2028\u2029]/i;
+
+// node_modules/.pnpm/@formatjs+icu-skeleton-parser@1.8.16/node_modules/@formatjs/icu-skeleton-parser/lib/number.js
+function parseNumberSkeletonFromString(skeleton) {
+  if (skeleton.length === 0) {
+    throw new Error("Number skeleton cannot be empty");
+  }
+  var stringTokens = skeleton.split(WHITE_SPACE_REGEX).filter(function(x) {
+    return x.length > 0;
+  });
+  var tokens = [];
+  for (var _i = 0, stringTokens_1 = stringTokens; _i < stringTokens_1.length; _i++) {
+    var stringToken = stringTokens_1[_i];
+    var stemAndOptions = stringToken.split("/");
+    if (stemAndOptions.length === 0) {
+      throw new Error("Invalid number skeleton");
+    }
+    var stem = stemAndOptions[0], options = stemAndOptions.slice(1);
+    for (var _a2 = 0, options_1 = options; _a2 < options_1.length; _a2++) {
+      var option = options_1[_a2];
+      if (option.length === 0) {
+        throw new Error("Invalid number skeleton");
+      }
+    }
+    tokens.push({ stem, options });
+  }
+  return tokens;
+}
+function icuUnitToEcma(unit) {
+  return unit.replace(/^(.*?)-/, "");
+}
+var FRACTION_PRECISION_REGEX = /^\.(?:(0+)(\*)?|(#+)|(0+)(#+))$/g;
+var SIGNIFICANT_PRECISION_REGEX = /^(@+)?(\+|#+)?[rs]?$/g;
+var INTEGER_WIDTH_REGEX = /(\*)(0+)|(#+)(0+)|(0+)/g;
+var CONCISE_INTEGER_WIDTH_REGEX = /^(0+)$/;
+function parseSignificantPrecision(str) {
+  var result = {};
+  if (str[str.length - 1] === "r") {
+    result.roundingPriority = "morePrecision";
+  } else if (str[str.length - 1] === "s") {
+    result.roundingPriority = "lessPrecision";
+  }
+  str.replace(SIGNIFICANT_PRECISION_REGEX, function(_, g1, g2) {
+    if (typeof g2 !== "string") {
+      result.minimumSignificantDigits = g1.length;
+      result.maximumSignificantDigits = g1.length;
+    } else if (g2 === "+") {
+      result.minimumSignificantDigits = g1.length;
+    } else if (g1[0] === "#") {
+      result.maximumSignificantDigits = g1.length;
+    } else {
+      result.minimumSignificantDigits = g1.length;
+      result.maximumSignificantDigits = g1.length + (typeof g2 === "string" ? g2.length : 0);
+    }
+    return "";
+  });
+  return result;
+}
+function parseSign(str) {
+  switch (str) {
+    case "sign-auto":
+      return {
+        signDisplay: "auto"
+      };
+    case "sign-accounting":
+    case "()":
+      return {
+        currencySign: "accounting"
+      };
+    case "sign-always":
+    case "+!":
+      return {
+        signDisplay: "always"
+      };
+    case "sign-accounting-always":
+    case "()!":
+      return {
+        signDisplay: "always",
+        currencySign: "accounting"
+      };
+    case "sign-except-zero":
+    case "+?":
+      return {
+        signDisplay: "exceptZero"
+      };
+    case "sign-accounting-except-zero":
+    case "()?":
+      return {
+        signDisplay: "exceptZero",
+        currencySign: "accounting"
+      };
+    case "sign-never":
+    case "+_":
+      return {
+        signDisplay: "never"
+      };
+  }
+}
+function parseConciseScientificAndEngineeringStem(stem) {
+  var result;
+  if (stem[0] === "E" && stem[1] === "E") {
+    result = {
+      notation: "engineering"
+    };
+    stem = stem.slice(2);
+  } else if (stem[0] === "E") {
+    result = {
+      notation: "scientific"
+    };
+    stem = stem.slice(1);
+  }
+  if (result) {
+    var signDisplay = stem.slice(0, 2);
+    if (signDisplay === "+!") {
+      result.signDisplay = "always";
+      stem = stem.slice(2);
+    } else if (signDisplay === "+?") {
+      result.signDisplay = "exceptZero";
+      stem = stem.slice(2);
+    }
+    if (!CONCISE_INTEGER_WIDTH_REGEX.test(stem)) {
+      throw new Error("Malformed concise eng/scientific notation");
+    }
+    result.minimumIntegerDigits = stem.length;
+  }
+  return result;
+}
+function parseNotationOptions(opt) {
+  var result = {};
+  var signOpts = parseSign(opt);
+  if (signOpts) {
+    return signOpts;
+  }
+  return result;
+}
+function parseNumberSkeleton(tokens) {
+  var result = {};
+  for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
+    var token = tokens_1[_i];
+    switch (token.stem) {
+      case "percent":
+      case "%":
+        result.style = "percent";
+        continue;
+      case "%x100":
+        result.style = "percent";
+        result.scale = 100;
+        continue;
+      case "currency":
+        result.style = "currency";
+        result.currency = token.options[0];
+        continue;
+      case "group-off":
+      case ",_":
+        result.useGrouping = false;
+        continue;
+      case "precision-integer":
+      case ".":
+        result.maximumFractionDigits = 0;
+        continue;
+      case "measure-unit":
+      case "unit":
+        result.style = "unit";
+        result.unit = icuUnitToEcma(token.options[0]);
+        continue;
+      case "compact-short":
+      case "K":
+        result.notation = "compact";
+        result.compactDisplay = "short";
+        continue;
+      case "compact-long":
+      case "KK":
+        result.notation = "compact";
+        result.compactDisplay = "long";
+        continue;
+      case "scientific":
+        result = __assign(__assign(__assign({}, result), { notation: "scientific" }), token.options.reduce(function(all, opt2) {
+          return __assign(__assign({}, all), parseNotationOptions(opt2));
+        }, {}));
+        continue;
+      case "engineering":
+        result = __assign(__assign(__assign({}, result), { notation: "engineering" }), token.options.reduce(function(all, opt2) {
+          return __assign(__assign({}, all), parseNotationOptions(opt2));
+        }, {}));
+        continue;
+      case "notation-simple":
+        result.notation = "standard";
+        continue;
+      // https://github.com/unicode-org/icu/blob/master/icu4c/source/i18n/unicode/unumberformatter.h
+      case "unit-width-narrow":
+        result.currencyDisplay = "narrowSymbol";
+        result.unitDisplay = "narrow";
+        continue;
+      case "unit-width-short":
+        result.currencyDisplay = "code";
+        result.unitDisplay = "short";
+        continue;
+      case "unit-width-full-name":
+        result.currencyDisplay = "name";
+        result.unitDisplay = "long";
+        continue;
+      case "unit-width-iso-code":
+        result.currencyDisplay = "symbol";
+        continue;
+      case "scale":
+        result.scale = parseFloat(token.options[0]);
+        continue;
+      case "rounding-mode-floor":
+        result.roundingMode = "floor";
+        continue;
+      case "rounding-mode-ceiling":
+        result.roundingMode = "ceil";
+        continue;
+      case "rounding-mode-down":
+        result.roundingMode = "trunc";
+        continue;
+      case "rounding-mode-up":
+        result.roundingMode = "expand";
+        continue;
+      case "rounding-mode-half-even":
+        result.roundingMode = "halfEven";
+        continue;
+      case "rounding-mode-half-down":
+        result.roundingMode = "halfTrunc";
+        continue;
+      case "rounding-mode-half-up":
+        result.roundingMode = "halfExpand";
+        continue;
+      // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#integer-width
+      case "integer-width":
+        if (token.options.length > 1) {
+          throw new RangeError("integer-width stems only accept a single optional option");
+        }
+        token.options[0].replace(INTEGER_WIDTH_REGEX, function(_, g1, g2, g3, g4, g5) {
+          if (g1) {
+            result.minimumIntegerDigits = g2.length;
+          } else if (g3 && g4) {
+            throw new Error("We currently do not support maximum integer digits");
+          } else if (g5) {
+            throw new Error("We currently do not support exact integer digits");
+          }
+          return "";
+        });
+        continue;
+    }
+    if (CONCISE_INTEGER_WIDTH_REGEX.test(token.stem)) {
+      result.minimumIntegerDigits = token.stem.length;
+      continue;
+    }
+    if (FRACTION_PRECISION_REGEX.test(token.stem)) {
+      if (token.options.length > 1) {
+        throw new RangeError("Fraction-precision stems only accept a single optional option");
+      }
+      token.stem.replace(FRACTION_PRECISION_REGEX, function(_, g1, g2, g3, g4, g5) {
+        if (g2 === "*") {
+          result.minimumFractionDigits = g1.length;
+        } else if (g3 && g3[0] === "#") {
+          result.maximumFractionDigits = g3.length;
+        } else if (g4 && g5) {
+          result.minimumFractionDigits = g4.length;
+          result.maximumFractionDigits = g4.length + g5.length;
+        } else {
+          result.minimumFractionDigits = g1.length;
+          result.maximumFractionDigits = g1.length;
+        }
+        return "";
+      });
+      var opt = token.options[0];
+      if (opt === "w") {
+        result = __assign(__assign({}, result), { trailingZeroDisplay: "stripIfInteger" });
+      } else if (opt) {
+        result = __assign(__assign({}, result), parseSignificantPrecision(opt));
+      }
+      continue;
+    }
+    if (SIGNIFICANT_PRECISION_REGEX.test(token.stem)) {
+      result = __assign(__assign({}, result), parseSignificantPrecision(token.stem));
+      continue;
+    }
+    var signOpts = parseSign(token.stem);
+    if (signOpts) {
+      result = __assign(__assign({}, result), signOpts);
+    }
+    var conciseScientificAndEngineeringOpts = parseConciseScientificAndEngineeringStem(token.stem);
+    if (conciseScientificAndEngineeringOpts) {
+      result = __assign(__assign({}, result), conciseScientificAndEngineeringOpts);
+    }
+  }
+  return result;
+}
+
+// node_modules/.pnpm/@formatjs+icu-messageformat-parser@2.11.4/node_modules/@formatjs/icu-messageformat-parser/lib/time-data.generated.js
+var timeData = {
+  "001": [
+    "H",
+    "h"
+  ],
+  "419": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "AC": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "AD": [
+    "H",
+    "hB"
+  ],
+  "AE": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "AF": [
+    "H",
+    "hb",
+    "hB",
+    "h"
+  ],
+  "AG": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "AI": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "AL": [
+    "h",
+    "H",
+    "hB"
+  ],
+  "AM": [
+    "H",
+    "hB"
+  ],
+  "AO": [
+    "H",
+    "hB"
+  ],
+  "AR": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "AS": [
+    "h",
+    "H"
+  ],
+  "AT": [
+    "H",
+    "hB"
+  ],
+  "AU": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "AW": [
+    "H",
+    "hB"
+  ],
+  "AX": [
+    "H"
+  ],
+  "AZ": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "BA": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "BB": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "BD": [
+    "h",
+    "hB",
+    "H"
+  ],
+  "BE": [
+    "H",
+    "hB"
+  ],
+  "BF": [
+    "H",
+    "hB"
+  ],
+  "BG": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "BH": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "BI": [
+    "H",
+    "h"
+  ],
+  "BJ": [
+    "H",
+    "hB"
+  ],
+  "BL": [
+    "H",
+    "hB"
+  ],
+  "BM": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "BN": [
+    "hb",
+    "hB",
+    "h",
+    "H"
+  ],
+  "BO": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "BQ": [
+    "H"
+  ],
+  "BR": [
+    "H",
+    "hB"
+  ],
+  "BS": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "BT": [
+    "h",
+    "H"
+  ],
+  "BW": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "BY": [
+    "H",
+    "h"
+  ],
+  "BZ": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "CA": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "CC": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "CD": [
+    "hB",
+    "H"
+  ],
+  "CF": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "CG": [
+    "H",
+    "hB"
+  ],
+  "CH": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "CI": [
+    "H",
+    "hB"
+  ],
+  "CK": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "CL": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "CM": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "CN": [
+    "H",
+    "hB",
+    "hb",
+    "h"
+  ],
+  "CO": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "CP": [
+    "H"
+  ],
+  "CR": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "CU": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "CV": [
+    "H",
+    "hB"
+  ],
+  "CW": [
+    "H",
+    "hB"
+  ],
+  "CX": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "CY": [
+    "h",
+    "H",
+    "hb",
+    "hB"
+  ],
+  "CZ": [
+    "H"
+  ],
+  "DE": [
+    "H",
+    "hB"
+  ],
+  "DG": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "DJ": [
+    "h",
+    "H"
+  ],
+  "DK": [
+    "H"
+  ],
+  "DM": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "DO": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "DZ": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "EA": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "EC": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "EE": [
+    "H",
+    "hB"
+  ],
+  "EG": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "EH": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "ER": [
+    "h",
+    "H"
+  ],
+  "ES": [
+    "H",
+    "hB",
+    "h",
+    "hb"
+  ],
+  "ET": [
+    "hB",
+    "hb",
+    "h",
+    "H"
+  ],
+  "FI": [
+    "H"
+  ],
+  "FJ": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "FK": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "FM": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "FO": [
+    "H",
+    "h"
+  ],
+  "FR": [
+    "H",
+    "hB"
+  ],
+  "GA": [
+    "H",
+    "hB"
+  ],
+  "GB": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "GD": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "GE": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "GF": [
+    "H",
+    "hB"
+  ],
+  "GG": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "GH": [
+    "h",
+    "H"
+  ],
+  "GI": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "GL": [
+    "H",
+    "h"
+  ],
+  "GM": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "GN": [
+    "H",
+    "hB"
+  ],
+  "GP": [
+    "H",
+    "hB"
+  ],
+  "GQ": [
+    "H",
+    "hB",
+    "h",
+    "hb"
+  ],
+  "GR": [
+    "h",
+    "H",
+    "hb",
+    "hB"
+  ],
+  "GT": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "GU": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "GW": [
+    "H",
+    "hB"
+  ],
+  "GY": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "HK": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "HN": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "HR": [
+    "H",
+    "hB"
+  ],
+  "HU": [
+    "H",
+    "h"
+  ],
+  "IC": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "ID": [
+    "H"
+  ],
+  "IE": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "IL": [
+    "H",
+    "hB"
+  ],
+  "IM": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "IN": [
+    "h",
+    "H"
+  ],
+  "IO": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "IQ": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "IR": [
+    "hB",
+    "H"
+  ],
+  "IS": [
+    "H"
+  ],
+  "IT": [
+    "H",
+    "hB"
+  ],
+  "JE": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "JM": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "JO": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "JP": [
+    "H",
+    "K",
+    "h"
+  ],
+  "KE": [
+    "hB",
+    "hb",
+    "H",
+    "h"
+  ],
+  "KG": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "KH": [
+    "hB",
+    "h",
+    "H",
+    "hb"
+  ],
+  "KI": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "KM": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "KN": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "KP": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "KR": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "KW": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "KY": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "KZ": [
+    "H",
+    "hB"
+  ],
+  "LA": [
+    "H",
+    "hb",
+    "hB",
+    "h"
+  ],
+  "LB": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "LC": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "LI": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "LK": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "LR": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "LS": [
+    "h",
+    "H"
+  ],
+  "LT": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "LU": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "LV": [
+    "H",
+    "hB",
+    "hb",
+    "h"
+  ],
+  "LY": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "MA": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "MC": [
+    "H",
+    "hB"
+  ],
+  "MD": [
+    "H",
+    "hB"
+  ],
+  "ME": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "MF": [
+    "H",
+    "hB"
+  ],
+  "MG": [
+    "H",
+    "h"
+  ],
+  "MH": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "MK": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "ML": [
+    "H"
+  ],
+  "MM": [
+    "hB",
+    "hb",
+    "H",
+    "h"
+  ],
+  "MN": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "MO": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "MP": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "MQ": [
+    "H",
+    "hB"
+  ],
+  "MR": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "MS": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "MT": [
+    "H",
+    "h"
+  ],
+  "MU": [
+    "H",
+    "h"
+  ],
+  "MV": [
+    "H",
+    "h"
+  ],
+  "MW": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "MX": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "MY": [
+    "hb",
+    "hB",
+    "h",
+    "H"
+  ],
+  "MZ": [
+    "H",
+    "hB"
+  ],
+  "NA": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "NC": [
+    "H",
+    "hB"
+  ],
+  "NE": [
+    "H"
+  ],
+  "NF": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "NG": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "NI": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "NL": [
+    "H",
+    "hB"
+  ],
+  "NO": [
+    "H",
+    "h"
+  ],
+  "NP": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "NR": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "NU": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "NZ": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "OM": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "PA": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "PE": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "PF": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "PG": [
+    "h",
+    "H"
+  ],
+  "PH": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "PK": [
+    "h",
+    "hB",
+    "H"
+  ],
+  "PL": [
+    "H",
+    "h"
+  ],
+  "PM": [
+    "H",
+    "hB"
+  ],
+  "PN": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "PR": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "PS": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "PT": [
+    "H",
+    "hB"
+  ],
+  "PW": [
+    "h",
+    "H"
+  ],
+  "PY": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "QA": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "RE": [
+    "H",
+    "hB"
+  ],
+  "RO": [
+    "H",
+    "hB"
+  ],
+  "RS": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "RU": [
+    "H"
+  ],
+  "RW": [
+    "H",
+    "h"
+  ],
+  "SA": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "SB": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "SC": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "SD": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "SE": [
+    "H"
+  ],
+  "SG": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "SH": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "SI": [
+    "H",
+    "hB"
+  ],
+  "SJ": [
+    "H"
+  ],
+  "SK": [
+    "H"
+  ],
+  "SL": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "SM": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "SN": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "SO": [
+    "h",
+    "H"
+  ],
+  "SR": [
+    "H",
+    "hB"
+  ],
+  "SS": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "ST": [
+    "H",
+    "hB"
+  ],
+  "SV": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "SX": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "SY": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "SZ": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "TA": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "TC": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "TD": [
+    "h",
+    "H",
+    "hB"
+  ],
+  "TF": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "TG": [
+    "H",
+    "hB"
+  ],
+  "TH": [
+    "H",
+    "h"
+  ],
+  "TJ": [
+    "H",
+    "h"
+  ],
+  "TL": [
+    "H",
+    "hB",
+    "hb",
+    "h"
+  ],
+  "TM": [
+    "H",
+    "h"
+  ],
+  "TN": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "TO": [
+    "h",
+    "H"
+  ],
+  "TR": [
+    "H",
+    "hB"
+  ],
+  "TT": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "TW": [
+    "hB",
+    "hb",
+    "h",
+    "H"
+  ],
+  "TZ": [
+    "hB",
+    "hb",
+    "H",
+    "h"
+  ],
+  "UA": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "UG": [
+    "hB",
+    "hb",
+    "H",
+    "h"
+  ],
+  "UM": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "US": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "UY": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "UZ": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "VA": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "VC": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "VE": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "VG": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "VI": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "VN": [
+    "H",
+    "h"
+  ],
+  "VU": [
+    "h",
+    "H"
+  ],
+  "WF": [
+    "H",
+    "hB"
+  ],
+  "WS": [
+    "h",
+    "H"
+  ],
+  "XK": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "YE": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "YT": [
+    "H",
+    "hB"
+  ],
+  "ZA": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "ZM": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "ZW": [
+    "H",
+    "h"
+  ],
+  "af-ZA": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "ar-001": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "ca-ES": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "en-001": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "en-HK": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "en-IL": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "en-MY": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "es-BR": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "es-ES": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "es-GQ": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "fr-CA": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "gl-ES": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "gu-IN": [
+    "hB",
+    "hb",
+    "h",
+    "H"
+  ],
+  "hi-IN": [
+    "hB",
+    "h",
+    "H"
+  ],
+  "it-CH": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "it-IT": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "kn-IN": [
+    "hB",
+    "h",
+    "H"
+  ],
+  "ml-IN": [
+    "hB",
+    "h",
+    "H"
+  ],
+  "mr-IN": [
+    "hB",
+    "hb",
+    "h",
+    "H"
+  ],
+  "pa-IN": [
+    "hB",
+    "hb",
+    "h",
+    "H"
+  ],
+  "ta-IN": [
+    "hB",
+    "h",
+    "hb",
+    "H"
+  ],
+  "te-IN": [
+    "hB",
+    "h",
+    "H"
+  ],
+  "zu-ZA": [
+    "H",
+    "hB",
+    "hb",
+    "h"
+  ]
+};
+
+// node_modules/.pnpm/@formatjs+icu-messageformat-parser@2.11.4/node_modules/@formatjs/icu-messageformat-parser/lib/date-time-pattern-generator.js
+function getBestPattern(skeleton, locale) {
+  var skeletonCopy = "";
+  for (var patternPos = 0; patternPos < skeleton.length; patternPos++) {
+    var patternChar = skeleton.charAt(patternPos);
+    if (patternChar === "j") {
+      var extraLength = 0;
+      while (patternPos + 1 < skeleton.length && skeleton.charAt(patternPos + 1) === patternChar) {
+        extraLength++;
+        patternPos++;
+      }
+      var hourLen = 1 + (extraLength & 1);
+      var dayPeriodLen = extraLength < 2 ? 1 : 3 + (extraLength >> 1);
+      var dayPeriodChar = "a";
+      var hourChar = getDefaultHourSymbolFromLocale(locale);
+      if (hourChar == "H" || hourChar == "k") {
+        dayPeriodLen = 0;
+      }
+      while (dayPeriodLen-- > 0) {
+        skeletonCopy += dayPeriodChar;
+      }
+      while (hourLen-- > 0) {
+        skeletonCopy = hourChar + skeletonCopy;
+      }
+    } else if (patternChar === "J") {
+      skeletonCopy += "H";
+    } else {
+      skeletonCopy += patternChar;
+    }
+  }
+  return skeletonCopy;
+}
+function getDefaultHourSymbolFromLocale(locale) {
+  var hourCycle = locale.hourCycle;
+  if (hourCycle === void 0 && // @ts-ignore hourCycle(s) is not identified yet
+  locale.hourCycles && // @ts-ignore
+  locale.hourCycles.length) {
+    hourCycle = locale.hourCycles[0];
+  }
+  if (hourCycle) {
+    switch (hourCycle) {
+      case "h24":
+        return "k";
+      case "h23":
+        return "H";
+      case "h12":
+        return "h";
+      case "h11":
+        return "K";
+      default:
+        throw new Error("Invalid hourCycle");
+    }
+  }
+  var languageTag = locale.language;
+  var regionTag;
+  if (languageTag !== "root") {
+    regionTag = locale.maximize().region;
+  }
+  var hourCycles = timeData[regionTag || ""] || timeData[languageTag || ""] || timeData["".concat(languageTag, "-001")] || timeData["001"];
+  return hourCycles[0];
+}
+
+// node_modules/.pnpm/@formatjs+icu-messageformat-parser@2.11.4/node_modules/@formatjs/icu-messageformat-parser/lib/parser.js
+var _a;
+var SPACE_SEPARATOR_START_REGEX = new RegExp("^".concat(SPACE_SEPARATOR_REGEX.source, "*"));
+var SPACE_SEPARATOR_END_REGEX = new RegExp("".concat(SPACE_SEPARATOR_REGEX.source, "*$"));
+function createLocation(start, end) {
+  return { start, end };
+}
+var hasNativeStartsWith = !!String.prototype.startsWith && "_a".startsWith("a", 1);
+var hasNativeFromCodePoint = !!String.fromCodePoint;
+var hasNativeFromEntries = !!Object.fromEntries;
+var hasNativeCodePointAt = !!String.prototype.codePointAt;
+var hasTrimStart = !!String.prototype.trimStart;
+var hasTrimEnd = !!String.prototype.trimEnd;
+var hasNativeIsSafeInteger = !!Number.isSafeInteger;
+var isSafeInteger = hasNativeIsSafeInteger ? Number.isSafeInteger : function(n) {
+  return typeof n === "number" && isFinite(n) && Math.floor(n) === n && Math.abs(n) <= 9007199254740991;
+};
+var REGEX_SUPPORTS_U_AND_Y = true;
+try {
+  re = RE("([^\\p{White_Space}\\p{Pattern_Syntax}]*)", "yu");
+  REGEX_SUPPORTS_U_AND_Y = ((_a = re.exec("a")) === null || _a === void 0 ? void 0 : _a[0]) === "a";
+} catch (_) {
+  REGEX_SUPPORTS_U_AND_Y = false;
+}
+var re;
+var startsWith = hasNativeStartsWith ? (
+  // Native
+  function startsWith2(s, search, position) {
+    return s.startsWith(search, position);
+  }
+) : (
+  // For IE11
+  function startsWith3(s, search, position) {
+    return s.slice(position, position + search.length) === search;
+  }
+);
+var fromCodePoint = hasNativeFromCodePoint ? String.fromCodePoint : (
+  // IE11
+  function fromCodePoint2() {
+    var codePoints = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      codePoints[_i] = arguments[_i];
+    }
+    var elements = "";
+    var length = codePoints.length;
+    var i = 0;
+    var code;
+    while (length > i) {
+      code = codePoints[i++];
+      if (code > 1114111)
+        throw RangeError(code + " is not a valid code point");
+      elements += code < 65536 ? String.fromCharCode(code) : String.fromCharCode(((code -= 65536) >> 10) + 55296, code % 1024 + 56320);
+    }
+    return elements;
+  }
+);
+var fromEntries = (
+  // native
+  hasNativeFromEntries ? Object.fromEntries : (
+    // Ponyfill
+    function fromEntries2(entries) {
+      var obj = {};
+      for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+        var _a2 = entries_1[_i], k = _a2[0], v = _a2[1];
+        obj[k] = v;
+      }
+      return obj;
+    }
+  )
+);
+var codePointAt = hasNativeCodePointAt ? (
+  // Native
+  function codePointAt2(s, index) {
+    return s.codePointAt(index);
+  }
+) : (
+  // IE 11
+  function codePointAt3(s, index) {
+    var size = s.length;
+    if (index < 0 || index >= size) {
+      return void 0;
+    }
+    var first = s.charCodeAt(index);
+    var second;
+    return first < 55296 || first > 56319 || index + 1 === size || (second = s.charCodeAt(index + 1)) < 56320 || second > 57343 ? first : (first - 55296 << 10) + (second - 56320) + 65536;
+  }
+);
+var trimStart = hasTrimStart ? (
+  // Native
+  function trimStart2(s) {
+    return s.trimStart();
+  }
+) : (
+  // Ponyfill
+  function trimStart3(s) {
+    return s.replace(SPACE_SEPARATOR_START_REGEX, "");
+  }
+);
+var trimEnd = hasTrimEnd ? (
+  // Native
+  function trimEnd2(s) {
+    return s.trimEnd();
+  }
+) : (
+  // Ponyfill
+  function trimEnd3(s) {
+    return s.replace(SPACE_SEPARATOR_END_REGEX, "");
+  }
+);
+function RE(s, flag) {
+  return new RegExp(s, flag);
+}
+var matchIdentifierAtIndex;
+if (REGEX_SUPPORTS_U_AND_Y) {
+  IDENTIFIER_PREFIX_RE_1 = RE("([^\\p{White_Space}\\p{Pattern_Syntax}]*)", "yu");
+  matchIdentifierAtIndex = function matchIdentifierAtIndex2(s, index) {
+    var _a2;
+    IDENTIFIER_PREFIX_RE_1.lastIndex = index;
+    var match = IDENTIFIER_PREFIX_RE_1.exec(s);
+    return (_a2 = match[1]) !== null && _a2 !== void 0 ? _a2 : "";
+  };
+} else {
+  matchIdentifierAtIndex = function matchIdentifierAtIndex2(s, index) {
+    var match = [];
+    while (true) {
+      var c = codePointAt(s, index);
+      if (c === void 0 || _isWhiteSpace(c) || _isPatternSyntax(c)) {
+        break;
+      }
+      match.push(c);
+      index += c >= 65536 ? 2 : 1;
+    }
+    return fromCodePoint.apply(void 0, match);
+  };
+}
+var IDENTIFIER_PREFIX_RE_1;
+var Parser = (
+  /** @class */
+  (function() {
+    function Parser2(message, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      this.message = message;
+      this.position = { offset: 0, line: 1, column: 1 };
+      this.ignoreTag = !!options.ignoreTag;
+      this.locale = options.locale;
+      this.requiresOtherClause = !!options.requiresOtherClause;
+      this.shouldParseSkeletons = !!options.shouldParseSkeletons;
+    }
+    Parser2.prototype.parse = function() {
+      if (this.offset() !== 0) {
+        throw Error("parser can only be used once");
+      }
+      return this.parseMessage(0, "", false);
+    };
+    Parser2.prototype.parseMessage = function(nestingLevel, parentArgType, expectingCloseTag) {
+      var elements = [];
+      while (!this.isEOF()) {
+        var char = this.char();
+        if (char === 123) {
+          var result = this.parseArgument(nestingLevel, expectingCloseTag);
+          if (result.err) {
+            return result;
+          }
+          elements.push(result.val);
+        } else if (char === 125 && nestingLevel > 0) {
+          break;
+        } else if (char === 35 && (parentArgType === "plural" || parentArgType === "selectordinal")) {
+          var position = this.clonePosition();
+          this.bump();
+          elements.push({
+            type: TYPE.pound,
+            location: createLocation(position, this.clonePosition())
+          });
+        } else if (char === 60 && !this.ignoreTag && this.peek() === 47) {
+          if (expectingCloseTag) {
+            break;
+          } else {
+            return this.error(ErrorKind.UNMATCHED_CLOSING_TAG, createLocation(this.clonePosition(), this.clonePosition()));
+          }
+        } else if (char === 60 && !this.ignoreTag && _isAlpha(this.peek() || 0)) {
+          var result = this.parseTag(nestingLevel, parentArgType);
+          if (result.err) {
+            return result;
+          }
+          elements.push(result.val);
+        } else {
+          var result = this.parseLiteral(nestingLevel, parentArgType);
+          if (result.err) {
+            return result;
+          }
+          elements.push(result.val);
+        }
+      }
+      return { val: elements, err: null };
+    };
+    Parser2.prototype.parseTag = function(nestingLevel, parentArgType) {
+      var startPosition = this.clonePosition();
+      this.bump();
+      var tagName = this.parseTagName();
+      this.bumpSpace();
+      if (this.bumpIf("/>")) {
+        return {
+          val: {
+            type: TYPE.literal,
+            value: "<".concat(tagName, "/>"),
+            location: createLocation(startPosition, this.clonePosition())
+          },
+          err: null
+        };
+      } else if (this.bumpIf(">")) {
+        var childrenResult = this.parseMessage(nestingLevel + 1, parentArgType, true);
+        if (childrenResult.err) {
+          return childrenResult;
+        }
+        var children = childrenResult.val;
+        var endTagStartPosition = this.clonePosition();
+        if (this.bumpIf("</")) {
+          if (this.isEOF() || !_isAlpha(this.char())) {
+            return this.error(ErrorKind.INVALID_TAG, createLocation(endTagStartPosition, this.clonePosition()));
+          }
+          var closingTagNameStartPosition = this.clonePosition();
+          var closingTagName = this.parseTagName();
+          if (tagName !== closingTagName) {
+            return this.error(ErrorKind.UNMATCHED_CLOSING_TAG, createLocation(closingTagNameStartPosition, this.clonePosition()));
+          }
+          this.bumpSpace();
+          if (!this.bumpIf(">")) {
+            return this.error(ErrorKind.INVALID_TAG, createLocation(endTagStartPosition, this.clonePosition()));
+          }
+          return {
+            val: {
+              type: TYPE.tag,
+              value: tagName,
+              children,
+              location: createLocation(startPosition, this.clonePosition())
+            },
+            err: null
+          };
+        } else {
+          return this.error(ErrorKind.UNCLOSED_TAG, createLocation(startPosition, this.clonePosition()));
+        }
+      } else {
+        return this.error(ErrorKind.INVALID_TAG, createLocation(startPosition, this.clonePosition()));
+      }
+    };
+    Parser2.prototype.parseTagName = function() {
+      var startOffset = this.offset();
+      this.bump();
+      while (!this.isEOF() && _isPotentialElementNameChar(this.char())) {
+        this.bump();
+      }
+      return this.message.slice(startOffset, this.offset());
+    };
+    Parser2.prototype.parseLiteral = function(nestingLevel, parentArgType) {
+      var start = this.clonePosition();
+      var value = "";
+      while (true) {
+        var parseQuoteResult = this.tryParseQuote(parentArgType);
+        if (parseQuoteResult) {
+          value += parseQuoteResult;
+          continue;
+        }
+        var parseUnquotedResult = this.tryParseUnquoted(nestingLevel, parentArgType);
+        if (parseUnquotedResult) {
+          value += parseUnquotedResult;
+          continue;
+        }
+        var parseLeftAngleResult = this.tryParseLeftAngleBracket();
+        if (parseLeftAngleResult) {
+          value += parseLeftAngleResult;
+          continue;
+        }
+        break;
+      }
+      var location = createLocation(start, this.clonePosition());
+      return {
+        val: { type: TYPE.literal, value, location },
+        err: null
+      };
+    };
+    Parser2.prototype.tryParseLeftAngleBracket = function() {
+      if (!this.isEOF() && this.char() === 60 && (this.ignoreTag || // If at the opening tag or closing tag position, bail.
+      !_isAlphaOrSlash(this.peek() || 0))) {
+        this.bump();
+        return "<";
+      }
+      return null;
+    };
+    Parser2.prototype.tryParseQuote = function(parentArgType) {
+      if (this.isEOF() || this.char() !== 39) {
+        return null;
+      }
+      switch (this.peek()) {
+        case 39:
+          this.bump();
+          this.bump();
+          return "'";
+        // '{', '<', '>', '}'
+        case 123:
+        case 60:
+        case 62:
+        case 125:
+          break;
+        case 35:
+          if (parentArgType === "plural" || parentArgType === "selectordinal") {
+            break;
+          }
+          return null;
+        default:
+          return null;
+      }
+      this.bump();
+      var codePoints = [this.char()];
+      this.bump();
+      while (!this.isEOF()) {
+        var ch = this.char();
+        if (ch === 39) {
+          if (this.peek() === 39) {
+            codePoints.push(39);
+            this.bump();
+          } else {
+            this.bump();
+            break;
+          }
+        } else {
+          codePoints.push(ch);
+        }
+        this.bump();
+      }
+      return fromCodePoint.apply(void 0, codePoints);
+    };
+    Parser2.prototype.tryParseUnquoted = function(nestingLevel, parentArgType) {
+      if (this.isEOF()) {
+        return null;
+      }
+      var ch = this.char();
+      if (ch === 60 || ch === 123 || ch === 35 && (parentArgType === "plural" || parentArgType === "selectordinal") || ch === 125 && nestingLevel > 0) {
+        return null;
+      } else {
+        this.bump();
+        return fromCodePoint(ch);
+      }
+    };
+    Parser2.prototype.parseArgument = function(nestingLevel, expectingCloseTag) {
+      var openingBracePosition = this.clonePosition();
+      this.bump();
+      this.bumpSpace();
+      if (this.isEOF()) {
+        return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
+      }
+      if (this.char() === 125) {
+        this.bump();
+        return this.error(ErrorKind.EMPTY_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));
+      }
+      var value = this.parseIdentifierIfPossible().value;
+      if (!value) {
+        return this.error(ErrorKind.MALFORMED_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));
+      }
+      this.bumpSpace();
+      if (this.isEOF()) {
+        return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
+      }
+      switch (this.char()) {
+        // Simple argument: `{name}`
+        case 125: {
+          this.bump();
+          return {
+            val: {
+              type: TYPE.argument,
+              // value does not include the opening and closing braces.
+              value,
+              location: createLocation(openingBracePosition, this.clonePosition())
+            },
+            err: null
+          };
+        }
+        // Argument with options: `{name, format, ...}`
+        case 44: {
+          this.bump();
+          this.bumpSpace();
+          if (this.isEOF()) {
+            return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
+          }
+          return this.parseArgumentOptions(nestingLevel, expectingCloseTag, value, openingBracePosition);
+        }
+        default:
+          return this.error(ErrorKind.MALFORMED_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));
+      }
+    };
+    Parser2.prototype.parseIdentifierIfPossible = function() {
+      var startingPosition = this.clonePosition();
+      var startOffset = this.offset();
+      var value = matchIdentifierAtIndex(this.message, startOffset);
+      var endOffset = startOffset + value.length;
+      this.bumpTo(endOffset);
+      var endPosition = this.clonePosition();
+      var location = createLocation(startingPosition, endPosition);
+      return { value, location };
+    };
+    Parser2.prototype.parseArgumentOptions = function(nestingLevel, expectingCloseTag, value, openingBracePosition) {
+      var _a2;
+      var typeStartPosition = this.clonePosition();
+      var argType = this.parseIdentifierIfPossible().value;
+      var typeEndPosition = this.clonePosition();
+      switch (argType) {
+        case "":
+          return this.error(ErrorKind.EXPECT_ARGUMENT_TYPE, createLocation(typeStartPosition, typeEndPosition));
+        case "number":
+        case "date":
+        case "time": {
+          this.bumpSpace();
+          var styleAndLocation = null;
+          if (this.bumpIf(",")) {
+            this.bumpSpace();
+            var styleStartPosition = this.clonePosition();
+            var result = this.parseSimpleArgStyleIfPossible();
+            if (result.err) {
+              return result;
+            }
+            var style = trimEnd(result.val);
+            if (style.length === 0) {
+              return this.error(ErrorKind.EXPECT_ARGUMENT_STYLE, createLocation(this.clonePosition(), this.clonePosition()));
+            }
+            var styleLocation = createLocation(styleStartPosition, this.clonePosition());
+            styleAndLocation = { style, styleLocation };
+          }
+          var argCloseResult = this.tryParseArgumentClose(openingBracePosition);
+          if (argCloseResult.err) {
+            return argCloseResult;
+          }
+          var location_1 = createLocation(openingBracePosition, this.clonePosition());
+          if (styleAndLocation && startsWith(styleAndLocation === null || styleAndLocation === void 0 ? void 0 : styleAndLocation.style, "::", 0)) {
+            var skeleton = trimStart(styleAndLocation.style.slice(2));
+            if (argType === "number") {
+              var result = this.parseNumberSkeletonFromString(skeleton, styleAndLocation.styleLocation);
+              if (result.err) {
+                return result;
+              }
+              return {
+                val: { type: TYPE.number, value, location: location_1, style: result.val },
+                err: null
+              };
+            } else {
+              if (skeleton.length === 0) {
+                return this.error(ErrorKind.EXPECT_DATE_TIME_SKELETON, location_1);
+              }
+              var dateTimePattern = skeleton;
+              if (this.locale) {
+                dateTimePattern = getBestPattern(skeleton, this.locale);
+              }
+              var style = {
+                type: SKELETON_TYPE.dateTime,
+                pattern: dateTimePattern,
+                location: styleAndLocation.styleLocation,
+                parsedOptions: this.shouldParseSkeletons ? parseDateTimeSkeleton(dateTimePattern) : {}
+              };
+              var type = argType === "date" ? TYPE.date : TYPE.time;
+              return {
+                val: { type, value, location: location_1, style },
+                err: null
+              };
+            }
+          }
+          return {
+            val: {
+              type: argType === "number" ? TYPE.number : argType === "date" ? TYPE.date : TYPE.time,
+              value,
+              location: location_1,
+              style: (_a2 = styleAndLocation === null || styleAndLocation === void 0 ? void 0 : styleAndLocation.style) !== null && _a2 !== void 0 ? _a2 : null
+            },
+            err: null
+          };
+        }
+        case "plural":
+        case "selectordinal":
+        case "select": {
+          var typeEndPosition_1 = this.clonePosition();
+          this.bumpSpace();
+          if (!this.bumpIf(",")) {
+            return this.error(ErrorKind.EXPECT_SELECT_ARGUMENT_OPTIONS, createLocation(typeEndPosition_1, __assign({}, typeEndPosition_1)));
+          }
+          this.bumpSpace();
+          var identifierAndLocation = this.parseIdentifierIfPossible();
+          var pluralOffset = 0;
+          if (argType !== "select" && identifierAndLocation.value === "offset") {
+            if (!this.bumpIf(":")) {
+              return this.error(ErrorKind.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, createLocation(this.clonePosition(), this.clonePosition()));
+            }
+            this.bumpSpace();
+            var result = this.tryParseDecimalInteger(ErrorKind.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, ErrorKind.INVALID_PLURAL_ARGUMENT_OFFSET_VALUE);
+            if (result.err) {
+              return result;
+            }
+            this.bumpSpace();
+            identifierAndLocation = this.parseIdentifierIfPossible();
+            pluralOffset = result.val;
+          }
+          var optionsResult = this.tryParsePluralOrSelectOptions(nestingLevel, argType, expectingCloseTag, identifierAndLocation);
+          if (optionsResult.err) {
+            return optionsResult;
+          }
+          var argCloseResult = this.tryParseArgumentClose(openingBracePosition);
+          if (argCloseResult.err) {
+            return argCloseResult;
+          }
+          var location_2 = createLocation(openingBracePosition, this.clonePosition());
+          if (argType === "select") {
+            return {
+              val: {
+                type: TYPE.select,
+                value,
+                options: fromEntries(optionsResult.val),
+                location: location_2
+              },
+              err: null
+            };
+          } else {
+            return {
+              val: {
+                type: TYPE.plural,
+                value,
+                options: fromEntries(optionsResult.val),
+                offset: pluralOffset,
+                pluralType: argType === "plural" ? "cardinal" : "ordinal",
+                location: location_2
+              },
+              err: null
+            };
+          }
+        }
+        default:
+          return this.error(ErrorKind.INVALID_ARGUMENT_TYPE, createLocation(typeStartPosition, typeEndPosition));
+      }
+    };
+    Parser2.prototype.tryParseArgumentClose = function(openingBracePosition) {
+      if (this.isEOF() || this.char() !== 125) {
+        return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
+      }
+      this.bump();
+      return { val: true, err: null };
+    };
+    Parser2.prototype.parseSimpleArgStyleIfPossible = function() {
+      var nestedBraces = 0;
+      var startPosition = this.clonePosition();
+      while (!this.isEOF()) {
+        var ch = this.char();
+        switch (ch) {
+          case 39: {
+            this.bump();
+            var apostrophePosition = this.clonePosition();
+            if (!this.bumpUntil("'")) {
+              return this.error(ErrorKind.UNCLOSED_QUOTE_IN_ARGUMENT_STYLE, createLocation(apostrophePosition, this.clonePosition()));
+            }
+            this.bump();
+            break;
+          }
+          case 123: {
+            nestedBraces += 1;
+            this.bump();
+            break;
+          }
+          case 125: {
+            if (nestedBraces > 0) {
+              nestedBraces -= 1;
+            } else {
+              return {
+                val: this.message.slice(startPosition.offset, this.offset()),
+                err: null
+              };
+            }
+            break;
+          }
+          default:
+            this.bump();
+            break;
+        }
+      }
+      return {
+        val: this.message.slice(startPosition.offset, this.offset()),
+        err: null
+      };
+    };
+    Parser2.prototype.parseNumberSkeletonFromString = function(skeleton, location) {
+      var tokens = [];
+      try {
+        tokens = parseNumberSkeletonFromString(skeleton);
+      } catch (e) {
+        return this.error(ErrorKind.INVALID_NUMBER_SKELETON, location);
+      }
+      return {
+        val: {
+          type: SKELETON_TYPE.number,
+          tokens,
+          location,
+          parsedOptions: this.shouldParseSkeletons ? parseNumberSkeleton(tokens) : {}
+        },
+        err: null
+      };
+    };
+    Parser2.prototype.tryParsePluralOrSelectOptions = function(nestingLevel, parentArgType, expectCloseTag, parsedFirstIdentifier) {
+      var _a2;
+      var hasOtherClause = false;
+      var options = [];
+      var parsedSelectors = /* @__PURE__ */ new Set();
+      var selector = parsedFirstIdentifier.value, selectorLocation = parsedFirstIdentifier.location;
+      while (true) {
+        if (selector.length === 0) {
+          var startPosition = this.clonePosition();
+          if (parentArgType !== "select" && this.bumpIf("=")) {
+            var result = this.tryParseDecimalInteger(ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR, ErrorKind.INVALID_PLURAL_ARGUMENT_SELECTOR);
+            if (result.err) {
+              return result;
+            }
+            selectorLocation = createLocation(startPosition, this.clonePosition());
+            selector = this.message.slice(startPosition.offset, this.offset());
+          } else {
+            break;
+          }
+        }
+        if (parsedSelectors.has(selector)) {
+          return this.error(parentArgType === "select" ? ErrorKind.DUPLICATE_SELECT_ARGUMENT_SELECTOR : ErrorKind.DUPLICATE_PLURAL_ARGUMENT_SELECTOR, selectorLocation);
+        }
+        if (selector === "other") {
+          hasOtherClause = true;
+        }
+        this.bumpSpace();
+        var openingBracePosition = this.clonePosition();
+        if (!this.bumpIf("{")) {
+          return this.error(parentArgType === "select" ? ErrorKind.EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT : ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT, createLocation(this.clonePosition(), this.clonePosition()));
+        }
+        var fragmentResult = this.parseMessage(nestingLevel + 1, parentArgType, expectCloseTag);
+        if (fragmentResult.err) {
+          return fragmentResult;
+        }
+        var argCloseResult = this.tryParseArgumentClose(openingBracePosition);
+        if (argCloseResult.err) {
+          return argCloseResult;
+        }
+        options.push([
+          selector,
+          {
+            value: fragmentResult.val,
+            location: createLocation(openingBracePosition, this.clonePosition())
+          }
+        ]);
+        parsedSelectors.add(selector);
+        this.bumpSpace();
+        _a2 = this.parseIdentifierIfPossible(), selector = _a2.value, selectorLocation = _a2.location;
+      }
+      if (options.length === 0) {
+        return this.error(parentArgType === "select" ? ErrorKind.EXPECT_SELECT_ARGUMENT_SELECTOR : ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR, createLocation(this.clonePosition(), this.clonePosition()));
+      }
+      if (this.requiresOtherClause && !hasOtherClause) {
+        return this.error(ErrorKind.MISSING_OTHER_CLAUSE, createLocation(this.clonePosition(), this.clonePosition()));
+      }
+      return { val: options, err: null };
+    };
+    Parser2.prototype.tryParseDecimalInteger = function(expectNumberError, invalidNumberError) {
+      var sign = 1;
+      var startingPosition = this.clonePosition();
+      if (this.bumpIf("+")) ; else if (this.bumpIf("-")) {
+        sign = -1;
+      }
+      var hasDigits = false;
+      var decimal = 0;
+      while (!this.isEOF()) {
+        var ch = this.char();
+        if (ch >= 48 && ch <= 57) {
+          hasDigits = true;
+          decimal = decimal * 10 + (ch - 48);
+          this.bump();
+        } else {
+          break;
+        }
+      }
+      var location = createLocation(startingPosition, this.clonePosition());
+      if (!hasDigits) {
+        return this.error(expectNumberError, location);
+      }
+      decimal *= sign;
+      if (!isSafeInteger(decimal)) {
+        return this.error(invalidNumberError, location);
+      }
+      return { val: decimal, err: null };
+    };
+    Parser2.prototype.offset = function() {
+      return this.position.offset;
+    };
+    Parser2.prototype.isEOF = function() {
+      return this.offset() === this.message.length;
+    };
+    Parser2.prototype.clonePosition = function() {
+      return {
+        offset: this.position.offset,
+        line: this.position.line,
+        column: this.position.column
+      };
+    };
+    Parser2.prototype.char = function() {
+      var offset = this.position.offset;
+      if (offset >= this.message.length) {
+        throw Error("out of bound");
+      }
+      var code = codePointAt(this.message, offset);
+      if (code === void 0) {
+        throw Error("Offset ".concat(offset, " is at invalid UTF-16 code unit boundary"));
+      }
+      return code;
+    };
+    Parser2.prototype.error = function(kind, location) {
+      return {
+        val: null,
+        err: {
+          kind,
+          message: this.message,
+          location
+        }
+      };
+    };
+    Parser2.prototype.bump = function() {
+      if (this.isEOF()) {
+        return;
+      }
+      var code = this.char();
+      if (code === 10) {
+        this.position.line += 1;
+        this.position.column = 1;
+        this.position.offset += 1;
+      } else {
+        this.position.column += 1;
+        this.position.offset += code < 65536 ? 1 : 2;
+      }
+    };
+    Parser2.prototype.bumpIf = function(prefix) {
+      if (startsWith(this.message, prefix, this.offset())) {
+        for (var i = 0; i < prefix.length; i++) {
+          this.bump();
+        }
+        return true;
+      }
+      return false;
+    };
+    Parser2.prototype.bumpUntil = function(pattern) {
+      var currentOffset = this.offset();
+      var index = this.message.indexOf(pattern, currentOffset);
+      if (index >= 0) {
+        this.bumpTo(index);
+        return true;
+      } else {
+        this.bumpTo(this.message.length);
+        return false;
+      }
+    };
+    Parser2.prototype.bumpTo = function(targetOffset) {
+      if (this.offset() > targetOffset) {
+        throw Error("targetOffset ".concat(targetOffset, " must be greater than or equal to the current offset ").concat(this.offset()));
+      }
+      targetOffset = Math.min(targetOffset, this.message.length);
+      while (true) {
+        var offset = this.offset();
+        if (offset === targetOffset) {
+          break;
+        }
+        if (offset > targetOffset) {
+          throw Error("targetOffset ".concat(targetOffset, " is at invalid UTF-16 code unit boundary"));
+        }
+        this.bump();
+        if (this.isEOF()) {
+          break;
+        }
+      }
+    };
+    Parser2.prototype.bumpSpace = function() {
+      while (!this.isEOF() && _isWhiteSpace(this.char())) {
+        this.bump();
+      }
+    };
+    Parser2.prototype.peek = function() {
+      if (this.isEOF()) {
+        return null;
+      }
+      var code = this.char();
+      var offset = this.offset();
+      var nextCode = this.message.charCodeAt(offset + (code >= 65536 ? 2 : 1));
+      return nextCode !== null && nextCode !== void 0 ? nextCode : null;
+    };
+    return Parser2;
+  })()
+);
+function _isAlpha(codepoint) {
+  return codepoint >= 97 && codepoint <= 122 || codepoint >= 65 && codepoint <= 90;
+}
+function _isAlphaOrSlash(codepoint) {
+  return _isAlpha(codepoint) || codepoint === 47;
+}
+function _isPotentialElementNameChar(c) {
+  return c === 45 || c === 46 || c >= 48 && c <= 57 || c === 95 || c >= 97 && c <= 122 || c >= 65 && c <= 90 || c == 183 || c >= 192 && c <= 214 || c >= 216 && c <= 246 || c >= 248 && c <= 893 || c >= 895 && c <= 8191 || c >= 8204 && c <= 8205 || c >= 8255 && c <= 8256 || c >= 8304 && c <= 8591 || c >= 11264 && c <= 12271 || c >= 12289 && c <= 55295 || c >= 63744 && c <= 64975 || c >= 65008 && c <= 65533 || c >= 65536 && c <= 983039;
+}
+function _isWhiteSpace(c) {
+  return c >= 9 && c <= 13 || c === 32 || c === 133 || c >= 8206 && c <= 8207 || c === 8232 || c === 8233;
+}
+function _isPatternSyntax(c) {
+  return c >= 33 && c <= 35 || c === 36 || c >= 37 && c <= 39 || c === 40 || c === 41 || c === 42 || c === 43 || c === 44 || c === 45 || c >= 46 && c <= 47 || c >= 58 && c <= 59 || c >= 60 && c <= 62 || c >= 63 && c <= 64 || c === 91 || c === 92 || c === 93 || c === 94 || c === 96 || c === 123 || c === 124 || c === 125 || c === 126 || c === 161 || c >= 162 && c <= 165 || c === 166 || c === 167 || c === 169 || c === 171 || c === 172 || c === 174 || c === 176 || c === 177 || c === 182 || c === 187 || c === 191 || c === 215 || c === 247 || c >= 8208 && c <= 8213 || c >= 8214 && c <= 8215 || c === 8216 || c === 8217 || c === 8218 || c >= 8219 && c <= 8220 || c === 8221 || c === 8222 || c === 8223 || c >= 8224 && c <= 8231 || c >= 8240 && c <= 8248 || c === 8249 || c === 8250 || c >= 8251 && c <= 8254 || c >= 8257 && c <= 8259 || c === 8260 || c === 8261 || c === 8262 || c >= 8263 && c <= 8273 || c === 8274 || c === 8275 || c >= 8277 && c <= 8286 || c >= 8592 && c <= 8596 || c >= 8597 && c <= 8601 || c >= 8602 && c <= 8603 || c >= 8604 && c <= 8607 || c === 8608 || c >= 8609 && c <= 8610 || c === 8611 || c >= 8612 && c <= 8613 || c === 8614 || c >= 8615 && c <= 8621 || c === 8622 || c >= 8623 && c <= 8653 || c >= 8654 && c <= 8655 || c >= 8656 && c <= 8657 || c === 8658 || c === 8659 || c === 8660 || c >= 8661 && c <= 8691 || c >= 8692 && c <= 8959 || c >= 8960 && c <= 8967 || c === 8968 || c === 8969 || c === 8970 || c === 8971 || c >= 8972 && c <= 8991 || c >= 8992 && c <= 8993 || c >= 8994 && c <= 9e3 || c === 9001 || c === 9002 || c >= 9003 && c <= 9083 || c === 9084 || c >= 9085 && c <= 9114 || c >= 9115 && c <= 9139 || c >= 9140 && c <= 9179 || c >= 9180 && c <= 9185 || c >= 9186 && c <= 9254 || c >= 9255 && c <= 9279 || c >= 9280 && c <= 9290 || c >= 9291 && c <= 9311 || c >= 9472 && c <= 9654 || c === 9655 || c >= 9656 && c <= 9664 || c === 9665 || c >= 9666 && c <= 9719 || c >= 9720 && c <= 9727 || c >= 9728 && c <= 9838 || c === 9839 || c >= 9840 && c <= 10087 || c === 10088 || c === 10089 || c === 10090 || c === 10091 || c === 10092 || c === 10093 || c === 10094 || c === 10095 || c === 10096 || c === 10097 || c === 10098 || c === 10099 || c === 10100 || c === 10101 || c >= 10132 && c <= 10175 || c >= 10176 && c <= 10180 || c === 10181 || c === 10182 || c >= 10183 && c <= 10213 || c === 10214 || c === 10215 || c === 10216 || c === 10217 || c === 10218 || c === 10219 || c === 10220 || c === 10221 || c === 10222 || c === 10223 || c >= 10224 && c <= 10239 || c >= 10240 && c <= 10495 || c >= 10496 && c <= 10626 || c === 10627 || c === 10628 || c === 10629 || c === 10630 || c === 10631 || c === 10632 || c === 10633 || c === 10634 || c === 10635 || c === 10636 || c === 10637 || c === 10638 || c === 10639 || c === 10640 || c === 10641 || c === 10642 || c === 10643 || c === 10644 || c === 10645 || c === 10646 || c === 10647 || c === 10648 || c >= 10649 && c <= 10711 || c === 10712 || c === 10713 || c === 10714 || c === 10715 || c >= 10716 && c <= 10747 || c === 10748 || c === 10749 || c >= 10750 && c <= 11007 || c >= 11008 && c <= 11055 || c >= 11056 && c <= 11076 || c >= 11077 && c <= 11078 || c >= 11079 && c <= 11084 || c >= 11085 && c <= 11123 || c >= 11124 && c <= 11125 || c >= 11126 && c <= 11157 || c === 11158 || c >= 11159 && c <= 11263 || c >= 11776 && c <= 11777 || c === 11778 || c === 11779 || c === 11780 || c === 11781 || c >= 11782 && c <= 11784 || c === 11785 || c === 11786 || c === 11787 || c === 11788 || c === 11789 || c >= 11790 && c <= 11798 || c === 11799 || c >= 11800 && c <= 11801 || c === 11802 || c === 11803 || c === 11804 || c === 11805 || c >= 11806 && c <= 11807 || c === 11808 || c === 11809 || c === 11810 || c === 11811 || c === 11812 || c === 11813 || c === 11814 || c === 11815 || c === 11816 || c === 11817 || c >= 11818 && c <= 11822 || c === 11823 || c >= 11824 && c <= 11833 || c >= 11834 && c <= 11835 || c >= 11836 && c <= 11839 || c === 11840 || c === 11841 || c === 11842 || c >= 11843 && c <= 11855 || c >= 11856 && c <= 11857 || c === 11858 || c >= 11859 && c <= 11903 || c >= 12289 && c <= 12291 || c === 12296 || c === 12297 || c === 12298 || c === 12299 || c === 12300 || c === 12301 || c === 12302 || c === 12303 || c === 12304 || c === 12305 || c >= 12306 && c <= 12307 || c === 12308 || c === 12309 || c === 12310 || c === 12311 || c === 12312 || c === 12313 || c === 12314 || c === 12315 || c === 12316 || c === 12317 || c >= 12318 && c <= 12319 || c === 12320 || c === 12336 || c === 64830 || c === 64831 || c >= 65093 && c <= 65094;
+}
+
+// node_modules/.pnpm/@formatjs+icu-messageformat-parser@2.11.4/node_modules/@formatjs/icu-messageformat-parser/lib/index.js
+function pruneLocation(els) {
+  els.forEach(function(el) {
+    delete el.location;
+    if (isSelectElement(el) || isPluralElement(el)) {
+      for (var k in el.options) {
+        delete el.options[k].location;
+        pruneLocation(el.options[k].value);
+      }
+    } else if (isNumberElement(el) && isNumberSkeleton(el.style)) {
+      delete el.style.location;
+    } else if ((isDateElement(el) || isTimeElement(el)) && isDateTimeSkeleton(el.style)) {
+      delete el.style.location;
+    } else if (isTagElement(el)) {
+      pruneLocation(el.children);
+    }
+  });
+}
+function parse(message, opts) {
+  if (opts === void 0) {
+    opts = {};
+  }
+  opts = __assign({ shouldParseSkeletons: true, requiresOtherClause: true }, opts);
+  var result = new Parser(message, opts).parse();
+  if (result.err) {
+    var error = SyntaxError(ErrorKind[result.err.kind]);
+    error.location = result.err.location;
+    error.originalMessage = result.err.message;
+    throw error;
+  }
+  if (!(opts === null || opts === void 0 ? void 0 : opts.captureLocation)) {
+    pruneLocation(result.val);
+  }
+  return result.val;
+}
+
+// src/markup.ts
+var markupStart = (name) => ({ type: "markup-start", name });
+var markupEnd = (name) => ({ type: "markup-end", name });
+var markupStandalone = (name) => ({ type: "markup-standalone", name });
+function markupPartToTag(part) {
+  switch (part.type) {
+    case "markup-start":
+      return `<${part.name}>`;
+    case "markup-end":
+      return `</${part.name}>`;
+    case "markup-standalone":
+      return `<${part.name}/>`;
+  }
+}
+
+// src/parse.ts
+var SELF_CLOSE_MARK = "\uE000";
+var SELF_CLOSE_RE = /<([\w][\w-]*)\s*\/>/y;
+function normalizeSelfClosingTags(source) {
+  let out = "";
+  let i = 0;
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === "'") {
+      if (source[i + 1] === "'") {
+        out += "''";
+        i += 2;
+        continue;
+      }
+      const next = source[i + 1];
+      if (next === "{" || next === "}" || next === "<" || next === "#") {
+        const end = source.indexOf("'", i + 1);
+        if (end === -1) {
+          out += source.slice(i);
+          break;
+        }
+        out += source.slice(i, end + 1);
+        i = end + 1;
+        continue;
+      }
+      out += ch;
+      i += 1;
+      continue;
+    }
+    if (ch === "<") {
+      SELF_CLOSE_RE.lastIndex = i;
+      const m = SELF_CLOSE_RE.exec(source);
+      if (m) {
+        out += `<${m[1]}>${SELF_CLOSE_MARK}</${m[1]}>`;
+        i += m[0].length;
+        continue;
+      }
+    }
+    out += ch;
+    i += 1;
+  }
+  return out;
+}
+function normalizeSkeletons(elements, src) {
+  for (const el of elements) {
+    if ((el.type === TYPE.number || el.type === TYPE.date || el.type === TYPE.time) && el.style && typeof el.style === "object") {
+      const loc = el.style.location;
+      el.style = loc ? src.slice(loc.start.offset, loc.end.offset) : String(el.style);
+    }
+    if (el.options) {
+      for (const key of Object.keys(el.options)) normalizeSkeletons(el.options[key].value, src);
+    }
+    if (el.children) normalizeSkeletons(el.children, src);
+  }
+}
+function parseIcu(source) {
+  const normalized = normalizeSelfClosingTags(source);
+  const ast = parse(normalized, {
+    ignoreTag: false,
+    requiresOtherClause: true,
+    captureLocation: true
+  });
+  normalizeSkeletons(ast, normalized);
+  return ast;
+}
+
+// src/icu-to-inlang.ts
+var EXACT_RE = /^=-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+var isExact = (k) => EXACT_RE.test(k);
+function messageToImport(args) {
+  const ast = parseIcu(args.source);
+  const ctx = { declarations: /* @__PURE__ */ new Map(), selectorNames: [] };
+  const variants = expand(ast, ctx, null);
+  return {
+    declarations: [...ctx.declarations.values()],
+    selectors: ctx.selectorNames.map((name) => ({ type: "variable-reference", name })),
+    variants
+  };
+}
+function addDecl(ctx, decl) {
+  if (!ctx.declarations.has(decl.name)) ctx.declarations.set(decl.name, decl);
+}
+function addSelectorName(ctx, name) {
+  if (!ctx.selectorNames.includes(name)) ctx.selectorNames.push(name);
+}
+function expand(elements, ctx, poundArg) {
+  let variants = [{ matches: [], pattern: [] }];
+  for (const el of elements) {
+    const next = [];
+    for (const v of variants) {
+      for (const ext of extendVariant(v, el, ctx, poundArg)) next.push(ext);
+    }
+    variants = next;
+  }
+  return variants;
+}
+function extendVariant(v, el, ctx, poundArg) {
+  if (el.type === TYPE.plural || el.type === TYPE.select) {
+    const sel = registerSelector(el, ctx);
+    const out = [];
+    for (const caseKey of orderCases(el)) {
+      const childPound = el.type === TYPE.plural ? el.value : poundArg;
+      const caseMatches = sel.matchesFor(caseKey);
+      for (const cv of expand(el.options[caseKey].value, ctx, childPound)) {
+        out.push({
+          matches: [...v.matches, ...caseMatches, ...cv.matches],
+          pattern: [...v.pattern, ...cv.pattern]
+        });
+      }
+    }
+    return out;
+  }
+  if (el.type === TYPE.tag) {
+    const name = el.value;
+    const children = el.children ?? [];
+    if (isSelfClosing(children)) {
+      return [{ matches: v.matches, pattern: [...v.pattern, markupStandalone(name)] }];
+    }
+    const out = [];
+    for (const cv of expand(children, ctx, poundArg)) {
+      out.push({
+        matches: [...v.matches, ...cv.matches],
+        pattern: [...v.pattern, markupStart(name), ...cv.pattern, markupEnd(name)]
+      });
+    }
+    return out;
+  }
+  return [{ matches: v.matches, pattern: [...v.pattern, ...mapSimple(el, ctx, poundArg)] }];
+}
+function isSelfClosing(children) {
+  return children.length === 1 && children[0].type === TYPE.literal && // biome-ignore lint/suspicious/noExplicitAny: FormatJS literal carries .value
+  children[0].value === SELF_CLOSE_MARK;
+}
+function orderCases(el) {
+  const keys = Object.keys(el.options);
+  const exacts = keys.filter(isExact);
+  const cldr = keys.filter((k) => !isExact(k) && k !== "other");
+  const other = keys.includes("other") ? ["other"] : [];
+  return [...exacts, ...cldr, ...other];
+}
+function registerSelector(el, ctx) {
+  const arg = el.value;
+  if (el.type === TYPE.select) {
+    addDecl(ctx, { type: "input-variable", name: arg });
+    addSelectorName(ctx, arg);
+    return {
+      matchesFor: (c) => c === "other" ? [{ type: "catchall-match", key: arg }] : [{ type: "literal-match", key: arg, value: c }]
+    };
+  }
+  const ordinal = el.pluralType === "ordinal";
+  const offset = el.offset ?? 0;
+  const word = ordinal ? "Ordinal" : "Plural";
+  const pluralName = `${arg}${word}${offset ? `Offset${offset}` : ""}`;
+  const options = [];
+  if (ordinal) options.push({ name: "type", value: { type: "literal", value: "ordinal" } });
+  if (offset) options.push({ name: "offset", value: { type: "literal", value: String(offset) } });
+  addDecl(ctx, { type: "input-variable", name: arg });
+  addDecl(ctx, {
+    type: "local-variable",
+    name: pluralName,
+    value: {
+      type: "expression",
+      arg: { type: "variable-reference", name: arg },
+      annotation: { type: "function-reference", name: "plural", options }
+    }
+  });
+  const hasExact = Object.keys(el.options).some(isExact);
+  const exactName = hasExact ? `${pluralName}Exact` : void 0;
+  if (exactName) {
+    addDecl(ctx, {
+      type: "local-variable",
+      name: exactName,
+      value: { type: "expression", arg: { type: "variable-reference", name: arg } }
+    });
+    addSelectorName(ctx, exactName);
+  }
+  addSelectorName(ctx, pluralName);
+  return {
+    matchesFor: (c) => {
+      const exactCase = isExact(c);
+      const isOther = c === "other";
+      const pluralMatch = isOther || exactCase ? { type: "catchall-match", key: pluralName } : { type: "literal-match", key: pluralName, value: c };
+      if (!exactName) return [pluralMatch];
+      const exactMatch = exactCase ? { type: "literal-match", key: exactName, value: c.slice(1) } : { type: "catchall-match", key: exactName };
+      return [exactMatch, pluralMatch];
+    }
+  };
+}
+function mapSimple(el, ctx, poundArg) {
+  switch (el.type) {
+    case TYPE.literal:
+      return [{ type: "text", value: el.value }];
+    case TYPE.argument:
+      addDecl(ctx, { type: "input-variable", name: el.value });
+      return [{ type: "expression", arg: { type: "variable-reference", name: el.value } }];
+    case TYPE.pound:
+      return poundArg ? [
+        {
+          type: "expression",
+          arg: { type: "variable-reference", name: poundArg },
+          annotation: { type: "function-reference", name: "icu:pound", options: [] }
+        }
+      ] : [{ type: "text", value: "#" }];
+    case TYPE.number:
+    case TYPE.date:
+    case TYPE.time: {
+      const numEl = el;
+      addDecl(ctx, { type: "input-variable", name: numEl.value });
+      const fn = el.type === TYPE.number ? "number" : el.type === TYPE.date ? "date" : "time";
+      const style = numEl.style;
+      const options = style ? [{ name: "style", value: { type: "literal", value: style } }] : [];
+      return [
+        {
+          type: "expression",
+          arg: { type: "variable-reference", name: numEl.value },
+          annotation: { type: "function-reference", name: fn, options }
+        }
+      ];
+    }
+    default:
+      throw new Error(`Type ICU non support\xE9 : ${el.type}`);
+  }
+}
+
+// src/inlang-to-icu.ts
+function bundleToMessageString(args) {
+  const { bundle, message, variants } = args;
+  if (variants.length === 0) return "";
+  if (message.selectors.length === 0) return patternToString(variants[0].pattern, false);
+  const icuSelectors = resolveIcuSelectors(message, bundle);
+  return reconstruct(icuSelectors, variants);
+}
+function declMap(bundle) {
+  return new Map(bundle.declarations.map((d) => [d.name, d]));
+}
+function resolveIcuSelectors(message, bundle) {
+  const decls = declMap(bundle);
+  const names = message.selectors.map((s) => s.name);
+  const consumed = /* @__PURE__ */ new Set();
+  const out = [];
+  function resolvePlural(pluralDecl, pluralKey, exactKey) {
+    const arg = pluralDecl.value.arg.name;
+    const ordinal = pluralDecl.value.annotation.options?.some(
+      // biome-ignore lint/suspicious/noExplicitAny: AST inlang dynamique
+      (o) => o.name === "type" && o.value.value === "ordinal"
+    );
+    const offset = Number(
+      // biome-ignore lint/suspicious/noExplicitAny: AST inlang dynamique
+      pluralDecl.value.annotation.options?.find((o) => o.name === "offset")?.value.value ?? 0
+    );
+    out.push({ arg, kind: ordinal ? "selectordinal" : "plural", offset, pluralKey, exactKey });
+  }
+  for (const name of names) {
+    if (consumed.has(name)) continue;
+    const decl = decls.get(name);
+    const isPlural = decl?.type === "local-variable" && decl.value?.annotation?.name === "plural";
+    const isExactCompanion = decl?.type === "local-variable" && decl.value && !decl.value.annotation;
+    if (isPlural) {
+      const arg = decl.value.arg.name;
+      const exactKey = names.find((n) => {
+        if (consumed.has(n) || n === name) return false;
+        const d = decls.get(n);
+        return d?.type === "local-variable" && d.value?.arg?.name === arg && !d.value?.annotation;
+      });
+      if (exactKey) consumed.add(exactKey);
+      resolvePlural(decl, name, exactKey);
+    } else if (isExactCompanion) {
+      const arg = decl.value.arg.name;
+      const pluralKey = names.find((n) => {
+        if (consumed.has(n) || n === name) return false;
+        const d = decls.get(n);
+        return d?.type === "local-variable" && d.value?.annotation?.name === "plural" && d.value?.arg?.name === arg;
+      });
+      if (pluralKey) {
+        consumed.add(pluralKey);
+        resolvePlural(decls.get(pluralKey), pluralKey, name);
+      } else {
+        out.push({ arg: name, kind: "select", offset: 0, selectKey: name });
+      }
+    } else {
+      out.push({ arg: name, kind: "select", offset: 0, selectKey: name });
+    }
+  }
+  return out;
+}
+function caseFor(sel, matches) {
+  if (sel.kind === "select") {
+    const m = matches.find((x) => x.key === sel.selectKey);
+    return m?.type === "literal-match" ? m.value : "other";
+  }
+  const exact = sel.exactKey ? matches.find((x) => x.key === sel.exactKey) : void 0;
+  if (exact?.type === "literal-match") return `=${exact.value}`;
+  const plural = matches.find((x) => x.key === sel.pluralKey);
+  return plural?.type === "literal-match" ? plural.value : "other";
+}
+function orderIcuCases(keys) {
+  const isEx = (k) => k.startsWith("=");
+  const exacts = keys.filter(isEx);
+  const cldr = keys.filter((k) => !isEx(k) && k !== "other");
+  const other = keys.includes("other") ? ["other"] : [];
+  return [...exacts, ...cldr, ...other];
+}
+function reconstruct(selectors, variants) {
+  const [sel, ...rest] = selectors;
+  const inPlural = sel.kind !== "select";
+  const groups = /* @__PURE__ */ new Map();
+  for (const v of variants) {
+    const c = caseFor(sel, v.matches);
+    let group = groups.get(c);
+    if (!group) {
+      group = [];
+      groups.set(c, group);
+    }
+    group.push(v);
+  }
+  const offsetStr = sel.offset ? `offset:${sel.offset} ` : "";
+  const head = `${sel.arg}, ${sel.kind}, ${offsetStr}`;
+  const body = orderIcuCases([...groups.keys()]).map((c) => {
+    const grp = groups.get(c) ?? [];
+    const inner = rest.length === 0 ? patternToString(grp[0].pattern, inPlural) : reconstruct(rest, grp);
+    return `${c} {${inner}}`;
+  }).join(" ");
+  return `{${head}${body}}`;
+}
+function patternToString(pattern, inPlural) {
+  return pattern.map((part) => {
+    const p = part;
+    switch (p.type) {
+      case "text":
+        return escapeText(p.value ?? "", inPlural);
+      case "expression":
+        return expressionToString(p);
+      case "markup-start":
+      case "markup-end":
+      case "markup-standalone":
+        return markupPartToTag(p);
+      default:
+        throw new Error(`part inconnue: ${p.type}`);
+    }
+  }).join("");
+}
+function expressionToString(expr) {
+  const ann = expr.annotation;
+  if (ann?.name === "icu:pound") return "#";
+  const name = expr.arg?.name ?? expr.arg?.value;
+  if (!ann) return `{${name}}`;
+  const style = ann.options?.find((o) => o.name === "style")?.value?.value;
+  return style ? `{${name}, ${ann.name}, ${style}}` : `{${name}, ${ann.name}}`;
+}
+function escapeText(s, inPlural) {
+  let out = s.replace(/'/g, "''");
+  out = out.replace(inPlural ? /[{}#<]/g : /[{}<]/g, (m) => `'${m}'`);
+  return out;
+}
+
+// src/settings.ts
+var import_typebox = __toESM(require_typebox());
+var settingsSchema = import_typebox.Type.Object({
+  pathPattern: import_typebox.Type.String({
+    pattern: ".*\\{locale\\}.*\\.json$",
+    examples: ["./messages/{locale}.json"],
+    title: "Path to language files",
+    description: "Must include `{locale}` and end with `.json`."
+  })
+});
+
+// src/plugin.ts
+var KEY = "plugin.donal2.richIcu";
+function pathPattern(settings) {
+  return settings[KEY]?.pathPattern ?? "./messages/{locale}.json";
+}
+var LOG_PREFIX = "[inlang-plugin-rich-icu]";
+var richIcuPlugin = {
+  key: KEY,
+  settingsSchema,
+  toBeImportedFiles: async ({ settings }) => {
+    const s = settings;
+    const pattern = pathPattern(s);
+    return s.locales.map((locale) => ({ path: pattern.replace("{locale}", locale), locale }));
+  },
+  importFiles: ({ files }) => {
+    const bundleMap = /* @__PURE__ */ new Map();
+    const bundles = [];
+    const messages = [];
+    const variants = [];
+    const decoder = new TextDecoder("utf-8");
+    for (const file of files) {
+      let json;
+      try {
+        json = JSON.parse(decoder.decode(file.content));
+      } catch (err) {
+        console.warn(
+          `${LOG_PREFIX} JSON invalide pour la locale "${file.locale}", fichier ignor\xE9 : ${err.message}`
+        );
+        continue;
+      }
+      for (const [key, value] of Object.entries(json)) {
+        if (key === "$schema") continue;
+        if (typeof value !== "string") {
+          console.warn(
+            `${LOG_PREFIX} valeur non-string ignor\xE9e pour "${key}" (locale "${file.locale}")`
+          );
+          continue;
+        }
+        let imported;
+        try {
+          imported = messageToImport({ source: value, bundleId: key, locale: file.locale });
+        } catch (err) {
+          console.warn(
+            `${LOG_PREFIX} ICU invalide pour "${key}" (locale "${file.locale}"), message ignor\xE9 : ${err.message}`
+          );
+          continue;
+        }
+        const { declarations, selectors, variants: vs } = imported;
+        let bundle = bundleMap.get(key);
+        if (!bundle) {
+          bundle = { id: key, declarations: [] };
+          bundleMap.set(key, bundle);
+          bundles.push(bundle);
+        }
+        for (const d of declarations) {
+          if (!bundle.declarations.some((x) => x.name === d.name)) bundle.declarations.push(d);
+        }
+        messages.push({ bundleId: key, locale: file.locale, selectors });
+        for (const v of vs) {
+          variants.push({
+            messageBundleId: key,
+            messageLocale: file.locale,
+            matches: v.matches,
+            pattern: v.pattern
+          });
+        }
+      }
+    }
+    return { bundles, messages, variants };
+  },
+  exportFiles: ({ bundles, messages, variants, settings }) => {
+    const s = settings;
+    const bundleById = new Map(bundles.map((b) => [b.id, b]));
+    const variantsByMsg = /* @__PURE__ */ new Map();
+    const keyOf = (v) => v.messageId != null ? `id:${v.messageId}` : `bl:${v.messageBundleId}\0${v.messageLocale}`;
+    for (const v of variants) {
+      const k = keyOf(v);
+      const arr = variantsByMsg.get(k);
+      if (arr) arr.push(v);
+      else variantsByMsg.set(k, [v]);
+    }
+    const byLocale = {};
+    for (const message of messages) {
+      const bundle = bundleById.get(message.bundleId);
+      if (!bundle) continue;
+      const vs = (message.id != null ? variantsByMsg.get(`id:${message.id}`) : void 0) ?? variantsByMsg.get(`bl:${message.bundleId}\0${message.locale}`) ?? [];
+      if (vs.length === 0) continue;
+      if (!byLocale[message.locale]) byLocale[message.locale] = {};
+      byLocale[message.locale][message.bundleId] = bundleToMessageString({
+        bundle,
+        message,
+        variants: vs
+      });
+    }
+    const pattern = pathPattern(s);
+    return Object.entries(byLocale).map(([locale, map]) => ({
+      locale,
+      name: pattern.replace("{locale}", locale).split("/").at(-1) ?? locale,
+      content: new TextEncoder().encode(`${JSON.stringify(map, null, "	")}
+`)
+    }));
+  }
+};
+
+// src/index.ts
+var index_default = richIcuPlugin;
+
+export { index_default as default, richIcuPlugin as plugin, richIcuPlugin };