kavrix 0.2.2 → 0.2.3

package/dist/chunks/chunk-EOAERCV7.js

@@ -0,0 +1,4499 @@
+/*! Kavrix is MIT licensed. Bundled third-party notices:
+
+commander@15.0.0 (MIT)
+(The MIT License)
+
+Copyright (c) 2011 TJ Holowaychuk <tj@vision-media.ca>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+zod@4.4.3 (MIT)
+MIT License
+
+Copyright (c) 2025 Colin McDonnell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+yaml@2.8.3 (ISC)
+Copyright Eemeli Aro <eemeli@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+
+mongodb@7.5.0 (Apache-2.0)
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+libsodium-wrappers@0.8.4 (ISC)
+Copyright (c) 2015-2026
+Ahmad Ben Mrad <batikhsouri at gmail dot org>
+Frank Denis <j at pureftpd dot org>
+Ryan Lester <ryan at cyph dot com>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+libsodium@0.8.4 (ISC)
+Copyright (c) 2015-2026
+Ahmad Ben Mrad <batikhsouri at gmail dot org>
+Frank Denis <j at pureftpd dot org>
+Ryan Lester <ryan at cyph dot com>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+ink@7.1.1 (MIT)
+MIT License
+
+Copyright (c) Vadym Demedes <vadimdemedes@hey.com> (https://github.com/vadimdemedes)
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+react@19.2.8 (MIT)
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+smol-toml@1.3.1 (BSD-3-Clause)
+Copyright (c) Squirrel Chat et al., All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+import { createRequire as __kavrixCreateRequire } from 'node:module';
+const __kavrixNodeRequire = __kavrixCreateRequire(import.meta.url);
+const __kavrixNodeBuiltin = (name) => __kavrixNodeRequire(`node:${name}`);
+import {
+  external_exports
+} from "./chunk-D4JYLAAS.js";
+
+// ../../packages/schemas/dist/identifiers.js
+var MIN_OPAQUE_ID_CHARS = 1;
+var MAX_OPAQUE_ID_CHARS = 128;
+var OPAQUE_ID_PATTERN_SOURCE = "^[A-Za-z0-9][A-Za-z0-9._~-]*$";
+var opaqueIdPattern = new RegExp(OPAQUE_ID_PATTERN_SOURCE);
+var opaqueId = external_exports.string().min(MIN_OPAQUE_ID_CHARS).max(MAX_OPAQUE_ID_CHARS).regex(opaqueIdPattern, "Must be an opaque identifier");
+var vaultIdSchema = opaqueId.brand();
+var databaseIdSchema = opaqueId.brand();
+var profileIdSchema = opaqueId.brand();
+var keySlotIdSchema = opaqueId.brand();
+var groupIdSchema = opaqueId.brand();
+var itemIdSchema = opaqueId.brand();
+var fieldIdSchema = opaqueId.brand();
+var noteIdSchema = opaqueId.brand();
+var templateIdSchema = opaqueId.brand();
+var templateMigrationIdSchema = opaqueId.brand();
+var deviceIdSchema = opaqueId.brand();
+var changeIdSchema = opaqueId.brand();
+var auditEventIdSchema = opaqueId.brand();
+var attachmentIdSchema = opaqueId.brand();
+var historyIdSchema = opaqueId.brand();
+var inviteIdSchema = opaqueId.brand();
+var policyIdSchema = opaqueId.brand();
+var grantIdSchema = opaqueId.brand();
+
+// ../../packages/schemas/dist/primitives.js
+var MAX_TEXT_BYTES = 1048576;
+var MAX_CIPHERTEXT_CHARS = 22369632;
+var MAX_SEMANTIC_VERSION = 4294967295;
+var MAX_SEMANTIC_REVISION = Number.MAX_SAFE_INTEGER;
+var textEncoder = new TextEncoder();
+function utf8ByteLength(value) {
+  return textEncoder.encode(value).byteLength;
+}
+var maxTextBytesSchema = external_exports.string().superRefine((value, context) => {
+  if (value.length > MAX_TEXT_BYTES || utf8ByteLength(value) > MAX_TEXT_BYTES) {
+    context.addIssue({
+      code: "too_big",
+      origin: "string",
+      maximum: MAX_TEXT_BYTES,
+      inclusive: true,
+      message: `Too big: expected string to have <=${String(MAX_TEXT_BYTES)} bytes`
+    });
+  }
+});
+var CURRENT_SCHEMA_VERSION = 1;
+var SUPPORTED_SCHEMA_VERSIONS = Object.freeze([
+  CURRENT_SCHEMA_VERSION
+]);
+var CURRENT_CRYPTOGRAPHIC_VERSION = 1;
+var SUPPORTED_CRYPTOGRAPHIC_VERSIONS = Object.freeze([
+  CURRENT_CRYPTOGRAPHIC_VERSION
+]);
+var CURRENT_TOKEN_VERSION = 1;
+var SUPPORTED_TOKEN_VERSIONS = Object.freeze([CURRENT_TOKEN_VERSION]);
+var CANONICAL_BASE64URL_PATTERN_SOURCE = "^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-][AQgw]|[A-Za-z0-9_-]{2}[AEIMQUYcgkosw048])?$";
+var CANONICAL_TIMESTAMP_CHARS = 24;
+var CANONICAL_TIMESTAMP_PATTERN_SOURCE = "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\\.[0-9]{3}Z$";
+var SHA256_DIGEST_BASE64URL_CHARS = 43;
+var canonicalBase64UrlPattern = new RegExp(CANONICAL_BASE64URL_PATTERN_SOURCE);
+var canonicalTimestampPattern = new RegExp(CANONICAL_TIMESTAMP_PATTERN_SOURCE);
+function hasCanonicalBase64UrlTerminalBits(value) {
+  if (value.length === 0)
+    return false;
+  const remainder = value.length % 4;
+  if (remainder === 1)
+    return false;
+  const tailLength = remainder === 0 ? Math.min(value.length, 4) : remainder;
+  return canonicalBase64UrlPattern.test(value.slice(-tailLength));
+}
+var timestampSchema = external_exports.iso.datetime({ offset: false, precision: 3 }).length(CANONICAL_TIMESTAMP_CHARS).regex(canonicalTimestampPattern);
+var revisionSchema = external_exports.number().int().nonnegative().brand();
+var positiveVersionSchema = external_exports.number().int().positive().max(MAX_SEMANTIC_VERSION).brand();
+var semanticVersionSchema = external_exports.number().int().positive().max(MAX_SEMANTIC_VERSION);
+var semanticRevisionSchema = external_exports.number().int().nonnegative().max(MAX_SEMANTIC_REVISION);
+var schemaVersionSchema = semanticVersionSchema.brand();
+var keyVersionSchema = semanticVersionSchema.brand();
+var templateVersionSchema = semanticVersionSchema.brand();
+var tokenVersionSchema = semanticVersionSchema.brand();
+var cryptographicVersionSchema = semanticVersionSchema.brand();
+var supportedSchemaVersionSchema = schemaVersionSchema.refine((value) => SUPPORTED_SCHEMA_VERSIONS.some((supported) => value === supported), { error: "Unsupported schema version" });
+var supportedCryptographicVersionSchema = cryptographicVersionSchema.refine((value) => SUPPORTED_CRYPTOGRAPHIC_VERSIONS.some((supported) => value === supported), { error: "Unsupported cryptographic version" });
+var supportedTokenVersionSchema = tokenVersionSchema.refine((value) => SUPPORTED_TOKEN_VERSIONS.some((supported) => value === supported), { error: "Unsupported token version" });
+var recordRevisionSchema = semanticRevisionSchema.brand();
+var vaultRevisionSchema = semanticRevisionSchema.brand();
+var changeSequenceSchema = semanticRevisionSchema.brand();
+var envelopeVersionSchema = external_exports.literal(1).brand();
+var associatedDataVersionSchema = external_exports.literal(1).brand();
+var keySlotVersionSchema = external_exports.literal(1).brand();
+var sortOrderSchema = external_exports.number().int().nonnegative();
+var nonEmptyTextSchema = external_exports.string().trim().min(1).max(256);
+var encryptedTextSchema = maxTextBytesSchema;
+var secretValueSchema = maxTextBytesSchema.brand();
+var secretBytesSchema = external_exports.instanceof(Uint8Array).refine((value) => value.byteLength > 0 && value.byteLength <= MAX_TEXT_BYTES, {
+  error: "Secret byte length is outside the supported range"
+}).brand();
+var base64UrlSchema = external_exports.string().min(1).max(MAX_CIPHERTEXT_CHARS).regex(/^[A-Za-z0-9_-]+$/, "Must use unpadded base64url encoding").refine(hasCanonicalBase64UrlTerminalBits, {
+  error: "Must use canonical unpadded base64url encoding"
+}).refine((value) => Buffer.from(value, "base64url").toString("base64url") === value, {
+  error: "Must use canonical unpadded base64url encoding"
+});
+var sha256DigestSchema = base64UrlSchema.length(SHA256_DIGEST_BASE64URL_CHARS).refine((value) => Buffer.from(value, "base64url").byteLength === 32, {
+  error: "SHA-256 digests must canonically encode exactly 32 bytes"
+}).brand();
+var slugSchema = external_exports.string().trim().min(1).max(128).regex(/^[\p{L}\p{N}](?:[\p{L}\p{N}._~-]|-(?!-))*$/u, "Invalid slug");
+
+// ../../packages/schemas/dist/encrypted-records.js
+var encryptedEntityTypeSchema = external_exports.enum([
+  "vault-preferences",
+  "group",
+  "item",
+  "attachment",
+  "attachment-chunk",
+  "audit-event",
+  "history",
+  "device-label",
+  "wrapped-root-key",
+  "wrapped-group-key",
+  "wrapped-item-key",
+  "wrapped-attachment-key"
+]);
+var encryptedPayloadPurposeSchema = external_exports.enum([
+  "vault-preferences",
+  "group-payload",
+  "item-payload",
+  "attachment-metadata",
+  "attachment-chunk",
+  "audit-event",
+  "history-event",
+  "device-label",
+  "vrk-slot",
+  "group-key",
+  "item-key",
+  "attachment-key"
+]);
+var AEAD_NONCE_BASE64URL_CHARS = 32;
+var AEAD_AUTHENTICATION_TAG_BASE64URL_CHARS = 22;
+var associatedDataBaseSchema = external_exports.object({
+  version: associatedDataVersionSchema,
+  schemaVersion: schemaVersionSchema,
+  keyVersion: keyVersionSchema,
+  vaultId: vaultIdSchema,
+  revision: vaultRevisionSchema.optional(),
+  metadataDigest: sha256DigestSchema.optional()
+}).strict();
+var unboundAssociatedData = {
+  groupId: external_exports.undefined().optional(),
+  parentId: external_exports.undefined().optional()
+};
+var associatedDataSchema = external_exports.discriminatedUnion("entityType", [
+  associatedDataBaseSchema.extend({
+    entityType: external_exports.literal("vault-preferences"),
+    entityId: vaultIdSchema,
+    purpose: external_exports.literal("vault-preferences"),
+    ...unboundAssociatedData
+  }),
+  associatedDataBaseSchema.extend({
+    entityType: external_exports.literal("group"),
+    entityId: groupIdSchema,
+    purpose: external_exports.literal("group-payload"),
+    ...unboundAssociatedData
+  }),
+  associatedDataBaseSchema.extend({
+    entityType: external_exports.literal("item"),
+    entityId: itemIdSchema,
+    purpose: external_exports.literal("item-payload"),
+    groupId: groupIdSchema,
+    parentId: external_exports.undefined().optional()
+  }),
+  associatedDataBaseSchema.extend({
+    entityType: external_exports.literal("attachment"),
+    entityId: attachmentIdSchema,
+    purpose: external_exports.literal("attachment-metadata"),
+    groupId: groupIdSchema,
+    parentId: itemIdSchema
+  }),
+  associatedDataBaseSchema.extend({
+    entityType: external_exports.literal("attachment-chunk"),
+    entityId: attachmentIdSchema,
+    purpose: external_exports.literal("attachment-chunk"),
+    groupId: groupIdSchema,
+    parentId: itemIdSchema
+  }),
+  associatedDataBaseSchema.extend({
+    entityType: external_exports.literal("audit-event"),
+    entityId: auditEventIdSchema,
+    purpose: external_exports.literal("audit-event"),
+    ...unboundAssociatedData
+  }),
+  associatedDataBaseSchema.extend({
+    entityType: external_exports.literal("history"),
+    entityId: historyIdSchema,
+    purpose: external_exports.literal("history-event"),
+    groupId: groupIdSchema,
+    parentId: itemIdSchema
+  }),
+  associatedDataBaseSchema.extend({
+    entityType: external_exports.literal("device-label"),
+    entityId: deviceIdSchema,
+    purpose: external_exports.literal("device-label"),
+    ...unboundAssociatedData
+  }),
+  associatedDataBaseSchema.extend({
+    entityType: external_exports.literal("wrapped-root-key"),
+    entityId: keySlotIdSchema,
+    purpose: external_exports.literal("vrk-slot"),
+    ...unboundAssociatedData
+  }),
+  associatedDataBaseSchema.extend({
+    entityType: external_exports.literal("wrapped-group-key"),
+    entityId: groupIdSchema,
+    purpose: external_exports.literal("group-key"),
+    ...unboundAssociatedData
+  }),
+  associatedDataBaseSchema.extend({
+    entityType: external_exports.literal("wrapped-item-key"),
+    entityId: itemIdSchema,
+    purpose: external_exports.literal("item-key"),
+    groupId: groupIdSchema,
+    parentId: external_exports.undefined().optional()
+  }),
+  associatedDataBaseSchema.extend({
+    entityType: external_exports.literal("wrapped-attachment-key"),
+    entityId: attachmentIdSchema,
+    purpose: external_exports.literal("attachment-key"),
+    groupId: groupIdSchema,
+    parentId: itemIdSchema
+  })
+]);
+var currentAssociatedDataSchema = associatedDataSchema.superRefine((associatedData, context) => {
+  if (!supportedSchemaVersionSchema.safeParse(associatedData.schemaVersion).success) {
+    context.addIssue({
+      code: "custom",
+      message: "Current envelopes require a supported schema version",
+      path: ["schemaVersion"]
+    });
+  }
+});
+var aeadEnvelopeSchema = external_exports.object({
+  version: envelopeVersionSchema,
+  algorithm: external_exports.literal("xchacha20-poly1305-ietf"),
+  nonce: base64UrlSchema,
+  ciphertext: base64UrlSchema,
+  authenticationTag: base64UrlSchema,
+  aad: currentAssociatedDataSchema,
+  keyVersion: keyVersionSchema
+}).strict().superRefine((envelope, context) => {
+  if (envelope.nonce.length !== AEAD_NONCE_BASE64URL_CHARS) {
+    context.addIssue({
+      code: "custom",
+      message: "Nonce length does not match the authenticated-encryption algorithm",
+      path: ["nonce"]
+    });
+  }
+  if (envelope.authenticationTag.length !== AEAD_AUTHENTICATION_TAG_BASE64URL_CHARS) {
+    context.addIssue({
+      code: "custom",
+      message: "Authentication tag must encode 16 bytes",
+      path: ["authenticationTag"]
+    });
+  }
+  if (envelope.keyVersion !== envelope.aad.keyVersion) {
+    context.addIssue({
+      code: "custom",
+      message: "Envelope key version must be authenticated in associated data",
+      path: ["keyVersion"]
+    });
+  }
+});
+var MAX_ENCRYPTED_DEVICE_LABEL_CIPHERTEXT_CHARS = 4096;
+var encryptedDeviceLabelSchema = aeadEnvelopeSchema.superRefine((envelope, context) => {
+  if (envelope.ciphertext.length > MAX_ENCRYPTED_DEVICE_LABEL_CIPHERTEXT_CHARS) {
+    context.addIssue({
+      code: "custom",
+      message: "Encrypted device-label ciphertext exceeds the canonical bound",
+      path: ["ciphertext"]
+    });
+  }
+  if (envelope.aad.entityType !== "device-label") {
+    context.addIssue({
+      code: "custom",
+      message: "Encrypted device labels require device-label associated data",
+      path: ["aad"]
+    });
+  }
+});
+var MAX_ATTACHMENT_CHUNK_PLAINTEXT_BYTES = 8 * 1024 * 1024;
+var SECRETSTREAM_CHUNK_OVERHEAD_BYTES = 17;
+var MAX_ATTACHMENT_CHUNKS = 1e6;
+var MAX_ATTACHMENT_STREAM_PLAINTEXT_BYTES = 4 * 1024 * 1024 * 1024;
+var MAX_ATTACHMENT_CHUNK_CIPHERTEXT_BYTES = MAX_ATTACHMENT_CHUNK_PLAINTEXT_BYTES + SECRETSTREAM_CHUNK_OVERHEAD_BYTES;
+var MAX_ATTACHMENT_STREAM_CIPHERTEXT_BYTES = MAX_ATTACHMENT_STREAM_PLAINTEXT_BYTES + MAX_ATTACHMENT_CHUNKS * SECRETSTREAM_CHUNK_OVERHEAD_BYTES;
+var SECRETSTREAM_HEADER_BASE64URL_CHARS = 32;
+var MIN_ATTACHMENT_CHUNK_CIPHERTEXT_CHARS = Math.ceil(SECRETSTREAM_CHUNK_OVERHEAD_BYTES * 4 / 3);
+var MAX_ATTACHMENT_CHUNK_CIPHERTEXT_CHARS = Math.ceil(MAX_ATTACHMENT_CHUNK_CIPHERTEXT_BYTES * 4 / 3);
+var secretStreamHeaderSchema = base64UrlSchema.length(SECRETSTREAM_HEADER_BASE64URL_CHARS).refine((value) => Buffer.from(value, "base64url").byteLength === 24, {
+  error: "Secretstream headers must canonically encode exactly 24 bytes"
+});
+var attachmentChunkCiphertextSchema = base64UrlSchema.min(MIN_ATTACHMENT_CHUNK_CIPHERTEXT_CHARS).max(MAX_ATTACHMENT_CHUNK_CIPHERTEXT_CHARS).refine((value) => {
+  const byteLength = Buffer.from(value, "base64url").byteLength;
+  return byteLength >= SECRETSTREAM_CHUNK_OVERHEAD_BYTES && byteLength <= MAX_ATTACHMENT_CHUNK_CIPHERTEXT_BYTES;
+}, { error: "Attachment chunk ciphertext is outside the canonical byte bounds" }).brand();
+var attachmentSecretStreamIdentitySchema = external_exports.object({
+  version: external_exports.literal(1),
+  algorithm: external_exports.literal("secretstream-xchacha20-poly1305"),
+  streamVersion: external_exports.literal(1),
+  schemaVersion: supportedSchemaVersionSchema,
+  keyVersion: keyVersionSchema,
+  vaultId: vaultIdSchema,
+  groupId: groupIdSchema,
+  itemId: itemIdSchema,
+  attachmentId: attachmentIdSchema
+});
+var attachmentSecretStreamHeaderRecordSchema = attachmentSecretStreamIdentitySchema.extend({
+  recordType: external_exports.literal("header"),
+  header: secretStreamHeaderSchema
+}).strict();
+var attachmentSecretStreamChunkRecordSchema = attachmentSecretStreamIdentitySchema.extend({
+  recordType: external_exports.literal("chunk"),
+  index: external_exports.number().int().nonnegative().max(MAX_ATTACHMENT_CHUNKS - 1),
+  ciphertext: attachmentChunkCiphertextSchema,
+  tag: external_exports.enum(["message", "final"])
+}).strict();
+var attachmentSecretStreamRecordSchema = external_exports.discriminatedUnion("recordType", [
+  attachmentSecretStreamHeaderRecordSchema,
+  attachmentSecretStreamChunkRecordSchema
+]);
+var persistedAttachmentHeaderRecordSchema = external_exports.object({
+  entityType: external_exports.literal("attachment-header"),
+  record: attachmentSecretStreamHeaderRecordSchema,
+  recordRevision: recordRevisionSchema,
+  contentHash: sha256DigestSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+}).strict();
+var persistedAttachmentChunkRecordSchema = external_exports.object({
+  entityType: external_exports.literal("attachment-chunk"),
+  record: attachmentSecretStreamChunkRecordSchema,
+  plaintextBytes: external_exports.number().int().nonnegative().max(MAX_ATTACHMENT_CHUNK_PLAINTEXT_BYTES),
+  recordRevision: recordRevisionSchema,
+  ciphertextHash: sha256DigestSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+}).strict().superRefine((chunk, context) => {
+  const ciphertextBytes = Buffer.from(chunk.record.ciphertext, "base64url").byteLength;
+  if (ciphertextBytes !== chunk.plaintextBytes + SECRETSTREAM_CHUNK_OVERHEAD_BYTES) {
+    context.addIssue({
+      code: "custom",
+      message: "Chunk ciphertext length must equal plaintext plus stream overhead",
+      path: ["plaintextBytes"]
+    });
+  }
+});
+var attachmentSecretStreamManifestSchema = attachmentSecretStreamIdentitySchema.extend({
+  manifestVersion: external_exports.literal(1),
+  header: secretStreamHeaderSchema,
+  chunkCount: external_exports.number().int().positive().max(MAX_ATTACHMENT_CHUNKS),
+  totalPlaintextBytes: external_exports.number().int().nonnegative().max(MAX_ATTACHMENT_STREAM_PLAINTEXT_BYTES),
+  plaintextSha256: sha256DigestSchema
+}).strict();
+var HKDF_SALT_BASE64URL_CHARS = 43;
+var ARGON2ID_SALT_BASE64URL_CHARS = 22;
+var KEY_DERIVATION_OUTPUT_BYTES = 32;
+var MIN_ARGON2_MEMORY_KIB = 65536;
+var MAX_ARGON2_MEMORY_KIB = 1048576;
+var MIN_ARGON2_PASSES = 3;
+var MAX_ARGON2_PASSES = 64;
+var MIN_ARGON2_PARALLELISM = 4;
+var MAX_ARGON2_PARALLELISM = 32;
+var MAX_DEVICE_KEY_PROVIDER_CHARS = 128;
+var hkdfSaltSchema = base64UrlSchema.length(HKDF_SALT_BASE64URL_CHARS);
+var argon2idSaltSchema = base64UrlSchema.length(ARGON2ID_SALT_BASE64URL_CHARS);
+var portableKeyDerivationSchema = external_exports.object({
+  algorithm: external_exports.literal("hkdf-sha256"),
+  version: external_exports.literal(1),
+  salt: hkdfSaltSchema,
+  context: external_exports.literal("credvault/v1/portable-key-wrap"),
+  outputLength: external_exports.literal(KEY_DERIVATION_OUTPUT_BYTES)
+}).strict();
+var passphraseDerivationSchema = external_exports.object({
+  algorithm: external_exports.literal("argon2id"),
+  version: external_exports.literal(1),
+  salt: argon2idSaltSchema,
+  memoryKiB: external_exports.number().int().min(MIN_ARGON2_MEMORY_KIB).max(MAX_ARGON2_MEMORY_KIB),
+  passes: external_exports.number().int().min(MIN_ARGON2_PASSES).max(MAX_ARGON2_PASSES),
+  parallelism: external_exports.number().int().min(MIN_ARGON2_PARALLELISM).max(MAX_ARGON2_PARALLELISM),
+  outputLength: external_exports.literal(KEY_DERIVATION_OUTPUT_BYTES)
+}).strict();
+var recoveryKeyDerivationSchema = external_exports.object({
+  algorithm: external_exports.literal("hkdf-sha256"),
+  version: external_exports.literal(1),
+  salt: hkdfSaltSchema,
+  context: external_exports.literal("credvault/v1/recovery-key-wrap"),
+  outputLength: external_exports.literal(KEY_DERIVATION_OUTPUT_BYTES)
+}).strict();
+var deviceKeyDerivationSchema = external_exports.object({
+  algorithm: external_exports.literal("hkdf-sha256"),
+  version: external_exports.literal(1),
+  salt: hkdfSaltSchema,
+  context: external_exports.literal("credvault/v1/device-key-wrap"),
+  outputLength: external_exports.literal(KEY_DERIVATION_OUTPUT_BYTES),
+  provider: external_exports.string().min(1).max(MAX_DEVICE_KEY_PROVIDER_CHARS)
+}).strict();
+var MIN_VAULT_KEY_SLOTS = 1;
+var MAX_VAULT_KEY_SLOTS = 128;
+var keySlotBaseSchema = external_exports.object({
+  slotVersion: keySlotVersionSchema,
+  id: keySlotIdSchema,
+  state: external_exports.enum(["pending", "active", "superseded", "revoked"]),
+  keyVersion: keyVersionSchema,
+  wrappedRootKey: aeadEnvelopeSchema,
+  createdAt: timestampSchema,
+  supersededAt: timestampSchema.optional(),
+  revokedAt: timestampSchema.optional()
+});
+var keySlotSchema = external_exports.discriminatedUnion("type", [
+  keySlotBaseSchema.extend({
+    type: external_exports.literal("portable-key"),
+    derivation: portableKeyDerivationSchema
+  }).strict(),
+  keySlotBaseSchema.extend({
+    type: external_exports.literal("passphrase"),
+    derivation: passphraseDerivationSchema
+  }).strict(),
+  keySlotBaseSchema.extend({
+    type: external_exports.literal("recovery-key"),
+    derivation: recoveryKeyDerivationSchema
+  }).strict(),
+  keySlotBaseSchema.extend({
+    type: external_exports.literal("device-key"),
+    derivation: deviceKeyDerivationSchema,
+    deviceId: deviceIdSchema
+  }).strict()
+]).superRefine((slot, context) => {
+  if (slot.wrappedRootKey.aad.entityType !== "wrapped-root-key") {
+    context.addIssue({
+      code: "custom",
+      message: "Key slot envelope must be bound as a wrapped root key",
+      path: ["wrappedRootKey", "aad", "entityType"]
+    });
+  }
+  if (slot.wrappedRootKey.aad.entityId !== slot.id) {
+    context.addIssue({
+      code: "custom",
+      message: "Key slot envelope is bound to a different slot",
+      path: ["wrappedRootKey", "aad", "entityId"]
+    });
+  }
+  if (slot.wrappedRootKey.keyVersion !== slot.keyVersion) {
+    context.addIssue({
+      code: "custom",
+      message: "Wrapped root-key version does not match its slot",
+      path: ["wrappedRootKey", "keyVersion"]
+    });
+  }
+  if (slot.state === "revoked" && slot.revokedAt === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Revoked slots require a timestamp",
+      path: ["revokedAt"]
+    });
+  }
+  if (slot.state !== "revoked" && slot.revokedAt !== void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Only revoked slots may have a revoked timestamp",
+      path: ["revokedAt"]
+    });
+  }
+  if (slot.state === "superseded" && slot.supersededAt === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Superseded slots require a timestamp",
+      path: ["supersededAt"]
+    });
+  }
+  if (slot.state !== "superseded" && slot.supersededAt !== void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Only superseded slots may have a superseded timestamp",
+      path: ["supersededAt"]
+    });
+  }
+});
+var vaultRecordSchema = external_exports.object({
+  id: vaultIdSchema,
+  schemaVersion: supportedSchemaVersionSchema,
+  cryptographicVersion: supportedCryptographicVersionSchema,
+  keySlots: external_exports.array(keySlotSchema).min(MIN_VAULT_KEY_SLOTS).max(MAX_VAULT_KEY_SLOTS),
+  currentKeyVersion: keyVersionSchema,
+  revision: vaultRevisionSchema,
+  encryptedPreferences: aeadEnvelopeSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+}).strict().superRefine((vault, context) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (const [index, slot] of vault.keySlots.entries()) {
+    if (slot.wrappedRootKey.aad.vaultId !== vault.id) {
+      context.addIssue({
+        code: "custom",
+        message: "Key slot belongs to a different vault",
+        path: ["keySlots", index, "wrappedRootKey", "aad", "vaultId"]
+      });
+    }
+    if (slot.wrappedRootKey.aad.schemaVersion !== vault.schemaVersion) {
+      context.addIssue({
+        code: "custom",
+        message: "Key slot schema version does not match its vault",
+        path: ["keySlots", index, "wrappedRootKey", "aad", "schemaVersion"]
+      });
+    }
+    if (ids.has(slot.id)) {
+      context.addIssue({
+        code: "custom",
+        message: "Key slot IDs must be unique",
+        path: ["keySlots", index, "id"]
+      });
+    }
+    ids.add(slot.id);
+  }
+  if (!vault.keySlots.some((slot) => slot.state === "active")) {
+    context.addIssue({
+      code: "custom",
+      message: "Vault requires an active unlock slot",
+      path: ["keySlots"]
+    });
+  }
+  if (!vault.keySlots.some((slot) => slot.state === "active" && slot.keyVersion === vault.currentKeyVersion)) {
+    context.addIssue({
+      code: "custom",
+      message: "Current key version requires an active unlock slot",
+      path: ["currentKeyVersion"]
+    });
+  }
+  if (vault.encryptedPreferences.aad.vaultId !== vault.id || vault.encryptedPreferences.aad.entityType !== "vault-preferences" || vault.encryptedPreferences.aad.entityId !== vault.id || vault.encryptedPreferences.aad.schemaVersion !== vault.schemaVersion) {
+    context.addIssue({
+      code: "custom",
+      message: "Encrypted preferences have invalid associated data",
+      path: ["encryptedPreferences", "aad"]
+    });
+  }
+});
+var encryptedGroupRecordSchema = external_exports.object({
+  id: groupIdSchema,
+  vaultId: vaultIdSchema,
+  schemaVersion: supportedSchemaVersionSchema,
+  wrappedGroupKey: aeadEnvelopeSchema,
+  encryptedPayload: aeadEnvelopeSchema,
+  templateVersion: templateVersionSchema,
+  recordRevision: recordRevisionSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  tombstonedAt: timestampSchema.optional()
+}).strict().superRefine((record, context) => {
+  validateEnvelopeBinding(context, record.encryptedPayload, record.vaultId, record.schemaVersion, "group", record.id);
+  validateEnvelopeBinding(context, record.wrappedGroupKey, record.vaultId, record.schemaVersion, "wrapped-group-key", record.id);
+});
+var encryptedItemRecordSchema = external_exports.object({
+  id: itemIdSchema,
+  vaultId: vaultIdSchema,
+  groupId: groupIdSchema,
+  schemaVersion: supportedSchemaVersionSchema,
+  wrappedItemKey: aeadEnvelopeSchema,
+  encryptedPayload: aeadEnvelopeSchema,
+  recordRevision: recordRevisionSchema,
+  ciphertextHash: sha256DigestSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  tombstonedAt: timestampSchema.optional()
+}).strict().superRefine((record, context) => {
+  validateEnvelopeBinding(context, record.encryptedPayload, record.vaultId, record.schemaVersion, "item", record.id, record.groupId);
+  validateEnvelopeBinding(context, record.wrappedItemKey, record.vaultId, record.schemaVersion, "wrapped-item-key", record.id, record.groupId);
+});
+var encryptedAttachmentRecordSchema = external_exports.object({
+  id: attachmentIdSchema,
+  vaultId: vaultIdSchema,
+  groupId: groupIdSchema,
+  itemId: itemIdSchema,
+  schemaVersion: supportedSchemaVersionSchema,
+  wrappedAttachmentKey: aeadEnvelopeSchema,
+  encryptedManifest: aeadEnvelopeSchema,
+  chunkCount: external_exports.number().int().positive().max(MAX_ATTACHMENT_CHUNKS),
+  recordRevision: recordRevisionSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  tombstonedAt: timestampSchema.optional()
+}).strict().superRefine((record, context) => {
+  validateEnvelopeBinding(context, record.encryptedManifest, record.vaultId, record.schemaVersion, "attachment", record.id, record.groupId, record.itemId);
+  validateEnvelopeBinding(context, record.wrappedAttachmentKey, record.vaultId, record.schemaVersion, "wrapped-attachment-key", record.id, record.groupId, record.itemId);
+  if (record.wrappedAttachmentKey.keyVersion !== record.encryptedManifest.keyVersion) {
+    context.addIssue({
+      code: "custom",
+      path: ["wrappedAttachmentKey", "keyVersion"],
+      message: "Attachment key envelopes must use one exact key version"
+    });
+  }
+});
+var encryptedAuditRecordSchema = external_exports.object({
+  id: auditEventIdSchema,
+  vaultId: vaultIdSchema,
+  schemaVersion: supportedSchemaVersionSchema,
+  encryptedPayload: aeadEnvelopeSchema,
+  recordRevision: recordRevisionSchema,
+  createdAt: timestampSchema
+}).strict().superRefine((record, context) => {
+  validateEnvelopeBinding(context, record.encryptedPayload, record.vaultId, record.schemaVersion, "audit-event", record.id);
+});
+var encryptedHistoryRecordSchema = external_exports.object({
+  id: historyIdSchema,
+  vaultId: vaultIdSchema,
+  groupId: groupIdSchema,
+  itemId: itemIdSchema,
+  schemaVersion: supportedSchemaVersionSchema,
+  encryptedPayload: aeadEnvelopeSchema,
+  itemRecordRevision: recordRevisionSchema,
+  ciphertextHash: sha256DigestSchema,
+  createdAt: timestampSchema
+}).strict().superRefine((record, context) => {
+  validateEnvelopeBinding(context, record.encryptedPayload, record.vaultId, record.schemaVersion, "history", record.id, record.groupId, record.itemId);
+});
+var encryptedRecordSchema = external_exports.union([
+  encryptedGroupRecordSchema,
+  encryptedItemRecordSchema,
+  encryptedAttachmentRecordSchema,
+  encryptedAuditRecordSchema,
+  encryptedHistoryRecordSchema
+]);
+function validateEnvelopeBinding(context, envelope, vaultId, schemaVersion, entityType, entityId, groupId, parentId) {
+  if (envelope.aad.vaultId !== vaultId || envelope.aad.schemaVersion !== schemaVersion || envelope.aad.entityType !== entityType || envelope.aad.entityId !== entityId || envelope.aad.groupId !== groupId || envelope.aad.parentId !== parentId) {
+    context.addIssue({
+      code: "custom",
+      message: "Envelope associated data does not match its record",
+      path: ["aad"]
+    });
+  }
+}
+
+// ../../packages/schemas/dist/content-hash.js
+import { createHash, timingSafeEqual } from "node:crypto";
+var BACKUP_STAGED_ENTRIES_DOMAIN = Buffer.from("kavrix/backup-staged-entries/v1", "utf8");
+function canonicalJson(value) {
+  if (value === null)
+    return "null";
+  if (typeof value === "string" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new TypeError("Canonical JSON rejects non-finite numbers.");
+    }
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => canonicalJson(entry)).join(",")}]`;
+  }
+  if (typeof value !== "object") {
+    throw new TypeError("Canonical JSON accepts only JSON values.");
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new TypeError("Canonical JSON rejects non-plain objects.");
+  }
+  const object = value;
+  return `{${Object.keys(object).sort().filter((key) => object[key] !== void 0).map((key) => `${JSON.stringify(key)}:${canonicalJson(object[key])}`).join(",")}}`;
+}
+function attachmentHeaderContentHash(header) {
+  return sha256DigestSchema.parse(createHash("sha256").update(canonicalJson(header.record), "utf8").digest("base64url"));
+}
+
+// ../../packages/schemas/dist/fields.js
+var fieldTypeSchema = external_exports.enum([
+  "text",
+  "secret",
+  "username",
+  "email",
+  "url",
+  "phone",
+  "number",
+  "boolean",
+  "date",
+  "datetime",
+  "multiline",
+  "secure-multiline",
+  "api-key",
+  "access-token",
+  "refresh-token",
+  "client-id",
+  "client-secret",
+  "connection-string",
+  "host",
+  "port",
+  "database-name",
+  "private-key",
+  "public-key",
+  "certificate",
+  "totp-secret",
+  "recovery-code-list",
+  "json",
+  "select",
+  "multi-select",
+  "tags",
+  "environment-map",
+  "command-snippet",
+  "attachment",
+  "item-reference",
+  "custom"
+]);
+var sensitiveFieldTypes = /* @__PURE__ */ new Set([
+  "secret",
+  "api-key",
+  "access-token",
+  "refresh-token",
+  "client-secret",
+  "connection-string",
+  "private-key",
+  "totp-secret",
+  "recovery-code-list",
+  "secure-multiline"
+]);
+function isSensitiveFieldType(fieldType) {
+  return sensitiveFieldTypes.has(fieldType);
+}
+var copyPolicySchema = external_exports.enum(["never", "allowed", "confirm"]);
+var revealPolicySchema = external_exports.enum(["never", "timed", "confirm"]);
+var reauthenticationPolicySchema = external_exports.enum(["never", "after-lock", "always"]);
+var exportPolicySchema = external_exports.enum(["never", "encrypted-only", "guarded"]);
+var namedValidationSchema = external_exports.enum([
+  "ascii",
+  "lowercase-ascii",
+  "alphanumeric-ascii",
+  "hostname",
+  "ipv4",
+  "base64url"
+]);
+var validationRulesSchema = external_exports.object({
+  minLength: external_exports.number().int().nonnegative().optional(),
+  maxLength: external_exports.number().int().positive().max(1048576).optional(),
+  namedValidation: namedValidationSchema.optional(),
+  min: external_exports.number().optional(),
+  max: external_exports.number().optional(),
+  allowedSchemes: external_exports.array(external_exports.string().min(1).max(32)).max(16).optional()
+}).strict().superRefine((rules, context) => {
+  if (rules.minLength !== void 0 && rules.maxLength !== void 0 && rules.minLength > rules.maxLength) {
+    context.addIssue({
+      code: "custom",
+      message: "Minimum length cannot exceed maximum length",
+      path: ["minLength"]
+    });
+  }
+  if (rules.min !== void 0 && rules.max !== void 0 && rules.min > rules.max) {
+    context.addIssue({
+      code: "custom",
+      message: "Minimum cannot exceed maximum",
+      path: ["min"]
+    });
+  }
+});
+var selectOptionSchema = external_exports.object({
+  value: external_exports.string().min(1).max(128),
+  label: nonEmptyTextSchema
+}).strict();
+var opaqueFieldValueIdSchema = external_exports.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._~-]*$/, "Must be an opaque identifier");
+var fieldValueElementIdSchema = opaqueFieldValueIdSchema.brand();
+var nonEmptyFieldTextSchema = encryptedTextSchema.refine((value) => value.length > 0, { error: "Present text values cannot be empty" });
+var nonEmptySecretValueSchema = secretValueSchema.refine((value) => value.length > 0, { error: "Present secret values cannot be empty" });
+var fieldScalarValueSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.object({ kind: external_exports.literal("text"), value: nonEmptyFieldTextSchema }).strict(),
+  external_exports.object({ kind: external_exports.literal("secret"), value: nonEmptySecretValueSchema }).strict(),
+  external_exports.object({ kind: external_exports.literal("number"), value: external_exports.number() }).strict(),
+  external_exports.object({ kind: external_exports.literal("boolean"), value: external_exports.boolean() }).strict(),
+  external_exports.object({ kind: external_exports.literal("item-reference"), itemId: itemIdSchema }).strict(),
+  external_exports.object({
+    kind: external_exports.literal("attachment-reference"),
+    attachmentId: attachmentIdSchema
+  }).strict(),
+  external_exports.object({
+    kind: external_exports.literal("environment-entry"),
+    key: external_exports.string().min(1).max(256),
+    value: external_exports.discriminatedUnion("classification", [
+      external_exports.object({
+        classification: external_exports.literal("text"),
+        value: nonEmptyFieldTextSchema
+      }).strict(),
+      external_exports.object({
+        classification: external_exports.literal("secret"),
+        value: nonEmptySecretValueSchema
+      }).strict()
+    ])
+  }).strict()
+]);
+var fieldValueElementLifecycleSchema = external_exports.discriminatedUnion("status", [
+  external_exports.object({
+    version: external_exports.literal(1),
+    status: external_exports.literal("available"),
+    usedAt: external_exports.undefined().optional()
+  }).strict(),
+  external_exports.object({
+    version: external_exports.literal(1),
+    status: external_exports.literal("used"),
+    usedAt: timestampSchema
+  }).strict()
+]);
+var fieldValueElementSchema = external_exports.object({
+  id: fieldValueElementIdSchema,
+  value: fieldScalarValueSchema,
+  lifecycle: fieldValueElementLifecycleSchema
+}).strict();
+var fieldValueContentSchema = external_exports.discriminatedUnion("cardinality", [
+  external_exports.object({
+    cardinality: external_exports.literal("single"),
+    value: fieldScalarValueSchema
+  }).strict(),
+  external_exports.object({
+    cardinality: external_exports.literal("multiple"),
+    elements: external_exports.array(fieldValueElementSchema).min(1).max(1e4)
+  }).strict().superRefine((content, context) => {
+    const ids = /* @__PURE__ */ new Set();
+    const environmentKeys = /* @__PURE__ */ new Set();
+    for (const [index, element] of content.elements.entries()) {
+      if (ids.has(element.id)) {
+        context.addIssue({
+          code: "custom",
+          message: "Repeatable field element IDs must be unique",
+          path: ["elements", index, "id"]
+        });
+      }
+      ids.add(element.id);
+      if (element.value.kind === "environment-entry") {
+        if (environmentKeys.has(element.value.key)) {
+          context.addIssue({
+            code: "custom",
+            message: "Environment entry keys must be unique",
+            path: ["elements", index, "value", "key"]
+          });
+        }
+        environmentKeys.add(element.value.key);
+      }
+    }
+  })
+]).refine((value) => new TextEncoder().encode(JSON.stringify(value)).byteLength <= 4194304, { error: "Field value content exceeds the aggregate size limit" });
+var missingFieldValueSchema = external_exports.object({ version: external_exports.literal(1), state: external_exports.literal("missing") }).strict();
+var emptyFieldValueSchema = external_exports.object({ version: external_exports.literal(1), state: external_exports.literal("empty") }).strict();
+var inapplicableFieldValueSchema = external_exports.object({
+  version: external_exports.literal(1),
+  state: external_exports.literal("inapplicable"),
+  reason: external_exports.string().trim().min(1).max(256).optional()
+}).strict();
+var unreadableFieldValueSchema = external_exports.object({
+  version: external_exports.literal(1),
+  state: external_exports.literal("unreadable"),
+  reason: external_exports.enum([
+    "unsupported-version",
+    "invalid-encoding",
+    "decryption-failed",
+    "reference-unavailable"
+  ])
+}).strict();
+var presentFieldValueSchema = external_exports.object({
+  version: external_exports.literal(1),
+  state: external_exports.literal("present"),
+  content: fieldValueContentSchema
+}).strict();
+var activeFieldValueSchema = external_exports.discriminatedUnion("state", [
+  missingFieldValueSchema,
+  emptyFieldValueSchema,
+  presentFieldValueSchema,
+  inapplicableFieldValueSchema,
+  unreadableFieldValueSchema
+]);
+var orphanedFieldValueSchema = external_exports.object({
+  version: external_exports.literal(1),
+  state: external_exports.literal("orphaned"),
+  originalValue: activeFieldValueSchema
+}).strict();
+var fieldValueSchema = external_exports.discriminatedUnion("state", [
+  missingFieldValueSchema,
+  emptyFieldValueSchema,
+  presentFieldValueSchema,
+  orphanedFieldValueSchema,
+  inapplicableFieldValueSchema,
+  unreadableFieldValueSchema
+]).refine((value) => new TextEncoder().encode(JSON.stringify(value)).byteLength <= 4194304, { error: "Field value exceeds the aggregate size limit" });
+var stableFieldKeySchema = external_exports.string().min(1).max(128).regex(/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/, "Invalid stable field key");
+var fieldDefinitionSchema = external_exports.object({
+  id: fieldIdSchema,
+  stableKey: stableFieldKeySchema,
+  label: nonEmptyTextSchema,
+  description: external_exports.string().trim().max(1024).optional(),
+  type: fieldTypeSchema,
+  required: external_exports.boolean(),
+  sensitive: external_exports.boolean(),
+  repeatable: external_exports.boolean(),
+  copyable: external_exports.boolean(),
+  searchableLocally: external_exports.boolean(),
+  showInPreview: external_exports.boolean(),
+  defaultValue: presentFieldValueSchema.optional(),
+  placeholder: external_exports.string().max(256).optional(),
+  validationRules: validationRulesSchema.optional(),
+  selectOptions: external_exports.array(selectOptionSchema).max(1e3).optional(),
+  environmentVariableName: external_exports.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(256).optional(),
+  copyPolicy: copyPolicySchema,
+  revealPolicy: revealPolicySchema,
+  reauthenticationPolicy: reauthenticationPolicySchema,
+  exportPolicy: exportPolicySchema,
+  sortOrder: sortOrderSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+}).strict().superRefine((field, context) => {
+  if (field.copyable !== (field.copyPolicy !== "never")) {
+    context.addIssue({
+      code: "custom",
+      message: "Copyable and copy policy must describe one canonical state",
+      path: ["copyPolicy"]
+    });
+  }
+  if (field.sensitive && field.defaultValue !== void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Sensitive fields cannot define default values",
+      path: ["defaultValue"]
+    });
+  }
+  if (isSensitiveFieldType(field.type) && !field.sensitive) {
+    context.addIssue({
+      code: "custom",
+      message: "This field type must be sensitive",
+      path: ["sensitive"]
+    });
+  }
+  if (field.sensitive && field.showInPreview) {
+    context.addIssue({
+      code: "custom",
+      message: "Sensitive fields cannot appear in list previews",
+      path: ["showInPreview"]
+    });
+  }
+  if (field.sensitive && field.reauthenticationPolicy === "never") {
+    context.addIssue({
+      code: "custom",
+      message: "Sensitive fields require reauthentication after locking",
+      path: ["reauthenticationPolicy"]
+    });
+  }
+  if (!field.sensitive && field.revealPolicy !== "never") {
+    context.addIssue({
+      code: "custom",
+      message: "Non-sensitive fields do not use reveal policies",
+      path: ["revealPolicy"]
+    });
+  }
+  const isSelect = field.type === "select" || field.type === "multi-select";
+  if (isSelect && (!field.selectOptions || field.selectOptions.length === 0)) {
+    context.addIssue({
+      code: "custom",
+      message: "Select fields require at least one option",
+      path: ["selectOptions"]
+    });
+  }
+  if (!isSelect && field.selectOptions !== void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Only select fields may define options",
+      path: ["selectOptions"]
+    });
+  }
+  if (field.defaultValue !== void 0 && !fieldValueMatchesDefinition(field, field.defaultValue)) {
+    context.addIssue({
+      code: "custom",
+      message: "A default value must satisfy its field definition",
+      path: ["defaultValue"]
+    });
+  }
+});
+var storedFieldValueSchema = external_exports.object({
+  fieldId: fieldIdSchema,
+  stableKey: stableFieldKeySchema,
+  value: activeFieldValueSchema,
+  updatedAt: timestampSchema
+}).strict();
+var archivedFieldValueReasonSchema = external_exports.enum([
+  "template-field-removed",
+  "type-conversion",
+  "user-archived"
+]);
+var archivedFieldValueSchema = external_exports.object({
+  definition: fieldDefinitionSchema,
+  value: orphanedFieldValueSchema,
+  sourceTemplateId: templateIdSchema,
+  sourceTemplateVersion: templateVersionSchema,
+  archivedAt: timestampSchema,
+  reason: archivedFieldValueReasonSchema
+}).strict().superRefine((archived, context) => {
+  if (!fieldValueMatchesDefinition(archived.definition, archived.value.originalValue)) {
+    context.addIssue({
+      code: "custom",
+      message: "Archived values must preserve a state valid for their definition",
+      path: ["value", "originalValue"]
+    });
+  }
+});
+var itemReferenceSchema = external_exports.object({
+  itemId: itemIdSchema,
+  relationship: external_exports.string().trim().min(1).max(128)
+}).strict();
+var collectionFieldTypes = /* @__PURE__ */ new Set([
+  "multi-select",
+  "tags",
+  "recovery-code-list",
+  "environment-map"
+]);
+function fieldExpectsMultipleValues(field) {
+  return field.repeatable || collectionFieldTypes.has(field.type);
+}
+function fieldValueMatchesDefinition(field, value) {
+  if (value.state === "orphaned")
+    return false;
+  if (value.state !== "present")
+    return !field.required;
+  const expectsMultiple = fieldExpectsMultipleValues(field);
+  if (expectsMultiple !== (value.content.cardinality === "multiple"))
+    return false;
+  const elements = value.content.cardinality === "multiple" ? value.content.elements : void 0;
+  if (field.type !== "recovery-code-list" && elements?.some(({ lifecycle }) => lifecycle.status === "used") === true) {
+    return false;
+  }
+  const candidates = value.content.cardinality === "multiple" ? value.content.elements.map(({ value: candidate }) => candidate) : [value.content.value];
+  return candidates.every((candidate) => singleValueMatchesType(field, candidate) && valueMatchesRules(field, candidate));
+}
+function singleValueMatchesType(field, value) {
+  switch (field.type) {
+    case "number":
+      return value.kind === "number";
+    case "port":
+      return value.kind === "number" && Number.isInteger(value.value) && value.value >= 1 && value.value <= 65535;
+    case "boolean":
+      return value.kind === "boolean";
+    case "attachment":
+      return value.kind === "attachment-reference";
+    case "item-reference":
+      return value.kind === "item-reference";
+    case "environment-map":
+      return value.kind === "environment-entry" && value.value.classification === (field.sensitive ? "secret" : "text");
+    case "json":
+      if (!isExpectedTextKind(field, value))
+        return false;
+      try {
+        JSON.parse(value.value);
+        return true;
+      } catch {
+        return false;
+      }
+    case "select":
+    case "multi-select":
+      return isExpectedTextKind(field, value) && selectValuesMatch(field, value.value);
+    case "email":
+      return isExpectedTextKind(field, value) && isSimpleEmail(value.value);
+    case "url":
+      if (!isExpectedTextKind(field, value))
+        return false;
+      try {
+        const parsed = new URL(value.value);
+        const schemes = field.validationRules?.allowedSchemes;
+        return schemes === void 0 || schemes.includes(parsed.protocol.slice(0, -1));
+      } catch {
+        return false;
+      }
+    default:
+      return isExpectedTextKind(field, value);
+  }
+}
+function isExpectedTextKind(field, value) {
+  return field.sensitive ? value.kind === "secret" : value.kind === "text";
+}
+function valueMatchesRules(field, value) {
+  const rules = field.validationRules;
+  if (rules === void 0)
+    return true;
+  if (value.kind === "text" || value.kind === "secret") {
+    if (rules.minLength !== void 0 && value.value.length < rules.minLength)
+      return false;
+    if (rules.maxLength !== void 0 && value.value.length > rules.maxLength)
+      return false;
+    if (rules.namedValidation !== void 0 && !matchesNamedValidation(rules.namedValidation, value.value))
+      return false;
+  }
+  if (value.kind === "number") {
+    if (rules.min !== void 0 && value.value < rules.min)
+      return false;
+    if (rules.max !== void 0 && value.value > rules.max)
+      return false;
+  }
+  return true;
+}
+function matchesNamedValidation(validation, value) {
+  switch (validation) {
+    case "ascii":
+      return everyCodeUnit(value, (code) => code <= 127);
+    case "lowercase-ascii":
+      return everyCodeUnit(value, (code) => code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 45 || code === 95);
+    case "alphanumeric-ascii":
+      return everyCodeUnit(value, (code) => code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122);
+    case "hostname":
+      return isHostname(value);
+    case "ipv4":
+      return isIpv4(value);
+    case "base64url":
+      return everyCodeUnit(value, (code) => code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 45 || code === 95);
+  }
+}
+function everyCodeUnit(value, predicate) {
+  if (value.length === 0)
+    return false;
+  for (let index = 0; index < value.length; index += 1) {
+    if (!predicate(value.charCodeAt(index)))
+      return false;
+  }
+  return true;
+}
+function isHostname(value) {
+  if (value.length === 0 || value.length > 253)
+    return false;
+  const labels = value.split(".");
+  return labels.every((label) => {
+    if (label.length === 0 || label.length > 63)
+      return false;
+    if (label.startsWith("-") || label.endsWith("-"))
+      return false;
+    return everyCodeUnit(label, (code) => code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 45);
+  });
+}
+function isIpv4(value) {
+  const parts = value.split(".");
+  if (parts.length !== 4)
+    return false;
+  return parts.every((part) => {
+    if (part.length === 0 || part.length > 3)
+      return false;
+    if (part.length > 1 && part.startsWith("0"))
+      return false;
+    if (!everyCodeUnit(part, (code) => code >= 48 && code <= 57))
+      return false;
+    const octet = Number(part);
+    return octet >= 0 && octet <= 255;
+  });
+}
+function isSimpleEmail(value) {
+  const at = value.indexOf("@");
+  if (at <= 0 || at !== value.lastIndexOf("@"))
+    return false;
+  const domain = value.slice(at + 1);
+  return domain.includes(".") && !value.includes(" ") && !value.includes("	");
+}
+function selectValuesMatch(field, value) {
+  return field.selectOptions?.some((option) => option.value === value) === true;
+}
+
+// ../../packages/schemas/dist/notes.js
+var noteSchema = external_exports.object({
+  id: noteIdSchema,
+  title: nonEmptyTextSchema,
+  content: secretValueSchema,
+  isSensitive: external_exports.boolean(),
+  isPinned: external_exports.boolean(),
+  tags: external_exports.array(external_exports.string().trim().min(1).max(128)).max(256),
+  sortOrder: sortOrderSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  archivedAt: timestampSchema.optional()
+}).strict();
+var noteCollectionSchema = external_exports.array(noteSchema).max(1e4).superRefine((notes, context) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (const [index, note] of notes.entries()) {
+    if (ids.has(note.id)) {
+      context.addIssue({
+        code: "custom",
+        message: "Note IDs must be unique",
+        path: [index, "id"]
+      });
+    }
+    ids.add(note.id);
+  }
+});
+
+// ../../packages/schemas/dist/templates.js
+var builtInTemplateKeySchema = external_exports.enum([
+  "email",
+  "database",
+  "api-oauth",
+  "server-ssh",
+  "cloud-provider",
+  "git-source-control",
+  "application-environment",
+  "software-license",
+  "secure-note",
+  "custom"
+]);
+var groupTemplateSchema = external_exports.object({
+  id: templateIdSchema,
+  name: nonEmptyTextSchema,
+  description: external_exports.string().trim().max(1024).optional(),
+  builtInKey: builtInTemplateKeySchema.optional(),
+  version: templateVersionSchema,
+  fields: external_exports.array(fieldDefinitionSchema).max(1e3),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+}).strict().superRefine((template, context) => {
+  const ids = /* @__PURE__ */ new Set();
+  const keys = /* @__PURE__ */ new Set();
+  const orders = /* @__PURE__ */ new Set();
+  for (const [index, field] of template.fields.entries()) {
+    if (ids.has(field.id)) {
+      context.addIssue({
+        code: "custom",
+        message: "Field IDs must be unique",
+        path: ["fields", index, "id"]
+      });
+    }
+    if (keys.has(field.stableKey)) {
+      context.addIssue({
+        code: "custom",
+        message: "Stable field keys must be unique",
+        path: ["fields", index, "stableKey"]
+      });
+    }
+    if (orders.has(field.sortOrder)) {
+      context.addIssue({
+        code: "custom",
+        message: "Field sort orders must be unique",
+        path: ["fields", index, "sortOrder"]
+      });
+    }
+    ids.add(field.id);
+    keys.add(field.stableKey);
+    orders.add(field.sortOrder);
+  }
+});
+var migrationStepBaseSchema = external_exports.object({
+  affectedItemCount: external_exports.number().int().nonnegative(),
+  requiresConfirmation: external_exports.boolean()
+});
+var templateMigrationStepSchema = external_exports.discriminatedUnion("kind", [
+  migrationStepBaseSchema.extend({
+    kind: external_exports.literal("add-field"),
+    field: fieldDefinitionSchema
+  }),
+  migrationStepBaseSchema.extend({
+    kind: external_exports.literal("restore-field"),
+    field: fieldDefinitionSchema
+  }),
+  migrationStepBaseSchema.extend({
+    kind: external_exports.literal("rename-label"),
+    fieldId: fieldIdSchema,
+    fromLabel: nonEmptyTextSchema,
+    toLabel: nonEmptyTextSchema
+  }),
+  migrationStepBaseSchema.extend({
+    kind: external_exports.literal("reorder-field"),
+    fieldId: fieldIdSchema,
+    fromSortOrder: sortOrderSchema,
+    toSortOrder: sortOrderSchema
+  }),
+  migrationStepBaseSchema.extend({
+    kind: external_exports.literal("change-required"),
+    fieldId: fieldIdSchema,
+    fromRequired: external_exports.boolean(),
+    toRequired: external_exports.boolean(),
+    missingValueCount: external_exports.number().int().nonnegative()
+  }),
+  migrationStepBaseSchema.extend({
+    kind: external_exports.literal("update-field-policy"),
+    fieldId: fieldIdSchema,
+    fromField: fieldDefinitionSchema,
+    toField: fieldDefinitionSchema
+  }),
+  migrationStepBaseSchema.extend({
+    kind: external_exports.literal("convert-type"),
+    fieldId: fieldIdSchema,
+    fromField: fieldDefinitionSchema,
+    toField: fieldDefinitionSchema,
+    fromType: fieldTypeSchema,
+    toType: fieldTypeSchema,
+    strategy: external_exports.enum([
+      "identity",
+      "number-to-string",
+      "string-to-number",
+      "boolean-to-string",
+      "string-to-boolean",
+      "archive-incompatible"
+    ]),
+    incompatibleValueCount: external_exports.number().int().nonnegative()
+  }),
+  migrationStepBaseSchema.extend({
+    kind: external_exports.literal("archive-field"),
+    field: fieldDefinitionSchema
+  })
+]);
+var templateMigrationPlanSchema = external_exports.object({
+  id: templateMigrationIdSchema,
+  fromVersion: templateVersionSchema,
+  toVersion: templateVersionSchema,
+  sourceTemplate: groupTemplateSchema,
+  targetTemplate: groupTemplateSchema,
+  itemSnapshots: external_exports.array(external_exports.object({
+    itemId: itemIdSchema,
+    revision: recordRevisionSchema
+  }).strict()).max(1e6),
+  steps: external_exports.array(templateMigrationStepSchema).max(4e3),
+  status: external_exports.enum(["pending", "running", "completed"]),
+  nextItemIndex: external_exports.number().int().nonnegative(),
+  totalItems: external_exports.number().int().nonnegative(),
+  auditEventId: auditEventIdSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+}).strict().superRefine((plan, context) => {
+  if (plan.toVersion <= plan.fromVersion) {
+    context.addIssue({
+      code: "custom",
+      message: "Migration target version must be newer",
+      path: ["toVersion"]
+    });
+  }
+  if (plan.targetTemplate.version !== plan.toVersion) {
+    context.addIssue({
+      code: "custom",
+      message: "Target template version must match the migration",
+      path: ["targetTemplate", "version"]
+    });
+  }
+  if (plan.sourceTemplate.version !== plan.fromVersion) {
+    context.addIssue({
+      code: "custom",
+      message: "Source template version must match the migration",
+      path: ["sourceTemplate", "version"]
+    });
+  }
+  if (plan.sourceTemplate.id !== plan.targetTemplate.id) {
+    context.addIssue({
+      code: "custom",
+      message: "A migration cannot change template identity",
+      path: ["targetTemplate", "id"]
+    });
+  }
+  if (plan.itemSnapshots.length !== plan.totalItems) {
+    context.addIssue({
+      code: "custom",
+      message: "Migration item snapshots must match the item count",
+      path: ["itemSnapshots"]
+    });
+  }
+  const snapshotIds = /* @__PURE__ */ new Set();
+  for (const [index, snapshot] of plan.itemSnapshots.entries()) {
+    if (snapshotIds.has(snapshot.itemId)) {
+      context.addIssue({
+        code: "custom",
+        message: "Migration item snapshots must have unique item IDs",
+        path: ["itemSnapshots", index, "itemId"]
+      });
+    }
+    snapshotIds.add(snapshot.itemId);
+  }
+  if (plan.nextItemIndex > plan.totalItems) {
+    context.addIssue({
+      code: "custom",
+      message: "Migration checkpoint exceeds item count",
+      path: ["nextItemIndex"]
+    });
+  }
+  if (plan.status === "completed" && plan.nextItemIndex !== plan.totalItems) {
+    context.addIssue({
+      code: "custom",
+      message: "Completed migration must include every item",
+      path: ["status"]
+    });
+  }
+});
+
+// ../../packages/schemas/dist/payloads.js
+var aliasesSchema = external_exports.array(external_exports.string().trim().min(1).max(256)).max(256);
+var tagsSchema = external_exports.array(external_exports.string().trim().min(1).max(128)).max(256);
+var copySequenceIdSchema = external_exports.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._~-]*$/).brand();
+var copySequenceSchema = external_exports.object({
+  id: copySequenceIdSchema,
+  name: nonEmptyTextSchema,
+  fieldKeys: external_exports.array(stableFieldKeySchema).min(1).max(100)
+}).strict().superRefine((sequence, context) => {
+  const keys = /* @__PURE__ */ new Set();
+  for (const [index, key] of sequence.fieldKeys.entries()) {
+    if (keys.has(key)) {
+      context.addIssue({
+        code: "custom",
+        message: "A copy sequence cannot contain the same field twice",
+        path: ["fieldKeys", index]
+      });
+    }
+    keys.add(key);
+  }
+});
+var groupPayloadSchema = external_exports.object({
+  id: groupIdSchema,
+  vaultId: vaultIdSchema,
+  name: nonEmptyTextSchema,
+  slug: slugSchema.optional(),
+  aliases: aliasesSchema,
+  description: external_exports.string().trim().max(8192).optional(),
+  icon: external_exports.string().max(64).optional(),
+  colorToken: external_exports.string().max(64).optional(),
+  tags: tagsSchema,
+  notes: noteCollectionSchema,
+  template: groupTemplateSchema,
+  sortOrder: sortOrderSchema,
+  revision: recordRevisionSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  archivedAt: timestampSchema.optional(),
+  deletedAt: timestampSchema.optional()
+}).strict();
+var itemPayloadV1Schema = external_exports.object({
+  version: external_exports.literal(1),
+  id: itemIdSchema,
+  vaultId: vaultIdSchema,
+  groupId: groupIdSchema,
+  templateId: templateIdSchema,
+  title: nonEmptyTextSchema,
+  slug: slugSchema.optional(),
+  aliases: aliasesSchema,
+  subtitle: external_exports.string().trim().max(512).optional(),
+  templateVersion: templateVersionSchema,
+  templateValues: external_exports.array(storedFieldValueSchema).max(1e3),
+  itemFields: external_exports.array(fieldDefinitionSchema).max(1e3),
+  itemValues: external_exports.array(storedFieldValueSchema).max(1e3),
+  archivedFieldValues: external_exports.array(archivedFieldValueSchema).max(1e4),
+  notes: noteCollectionSchema,
+  tags: tagsSchema,
+  favorite: external_exports.boolean(),
+  environment: external_exports.string().trim().max(128).optional(),
+  owner: external_exports.string().trim().min(1).max(512).optional(),
+  purpose: external_exports.string().trim().min(1).max(2048).optional(),
+  productionSensitive: external_exports.boolean(),
+  expiresAt: timestampSchema.optional(),
+  rotationIntervalDays: external_exports.number().int().positive().max(36500).optional(),
+  lastRotatedAt: timestampSchema.optional(),
+  lastVerifiedAt: timestampSchema.optional(),
+  relatedItemIds: external_exports.array(itemIdSchema).max(1e3),
+  attachmentIds: external_exports.array(attachmentIdSchema).max(1e3),
+  copySequences: external_exports.array(copySequenceSchema).max(100),
+  revision: recordRevisionSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  archivedAt: timestampSchema.optional(),
+  deletedAt: timestampSchema.optional()
+}).strict().superRefine((item, context) => {
+  const fieldIds = /* @__PURE__ */ new Set();
+  const stableKeys = /* @__PURE__ */ new Set();
+  const templateFieldIds = /* @__PURE__ */ new Set();
+  const templateStableKeys = /* @__PURE__ */ new Set();
+  for (const [index, value] of [
+    ...item.templateValues,
+    ...item.itemValues
+  ].entries()) {
+    if (fieldIds.has(value.fieldId) || stableKeys.has(value.stableKey)) {
+      context.addIssue({
+        code: "custom",
+        message: "Active field values must have unique IDs and stable keys",
+        path: ["templateValues", index]
+      });
+    }
+    fieldIds.add(value.fieldId);
+    stableKeys.add(value.stableKey);
+    if (index < item.templateValues.length) {
+      templateFieldIds.add(value.fieldId);
+      templateStableKeys.add(value.stableKey);
+    }
+  }
+  const itemDefinitionsById = /* @__PURE__ */ new Map();
+  const itemDefinitionKeys = /* @__PURE__ */ new Set();
+  for (const [index, definition] of item.itemFields.entries()) {
+    if (itemDefinitionsById.has(definition.id) || itemDefinitionKeys.has(definition.stableKey) || templateFieldIds.has(definition.id) || templateStableKeys.has(definition.stableKey)) {
+      context.addIssue({
+        code: "custom",
+        message: "Item-only field definitions must be unique and cannot shadow template fields",
+        path: ["itemFields", index]
+      });
+    }
+    itemDefinitionsById.set(definition.id, definition);
+    itemDefinitionKeys.add(definition.stableKey);
+  }
+  const itemValueIds = /* @__PURE__ */ new Set();
+  for (const [index, value] of item.itemValues.entries()) {
+    const definition = itemDefinitionsById.get(value.fieldId);
+    const definitionMatches = definition?.stableKey === value.stableKey && fieldValueMatchesDefinition(definition, value.value);
+    if (itemValueIds.has(value.fieldId) || !definitionMatches) {
+      context.addIssue({
+        code: "custom",
+        message: "Item-only values must match one unique item-only definition",
+        path: ["itemValues", index]
+      });
+    }
+    itemValueIds.add(value.fieldId);
+  }
+  for (const [index, definition] of item.itemFields.entries()) {
+    const stored = item.itemValues.find((value) => value.fieldId === definition.id);
+    if (definition.required && (stored === void 0 || !fieldValueMatchesDefinition(definition, stored.value))) {
+      context.addIssue({
+        code: "custom",
+        message: "Required item-only fields must have a value",
+        path: ["itemFields", index]
+      });
+    }
+  }
+  const activeDefinitionIds = /* @__PURE__ */ new Set([
+    ...item.templateValues.map(({ fieldId }) => fieldId),
+    ...item.itemFields.map(({ id }) => id)
+  ]);
+  const activeDefinitionKeys = /* @__PURE__ */ new Set([
+    ...item.templateValues.map(({ stableKey }) => stableKey),
+    ...item.itemFields.map(({ stableKey }) => stableKey)
+  ]);
+  const archivedIds = /* @__PURE__ */ new Set();
+  const archivedKeys = /* @__PURE__ */ new Set();
+  for (const [index, archived] of item.archivedFieldValues.entries()) {
+    if (archivedIds.has(archived.definition.id) || archivedKeys.has(archived.definition.stableKey) || activeDefinitionIds.has(archived.definition.id) || activeDefinitionKeys.has(archived.definition.stableKey)) {
+      context.addIssue({
+        code: "custom",
+        message: "Archived field IDs and stable keys must be unique and disjoint from active fields",
+        path: ["archivedFieldValues", index]
+      });
+    }
+    archivedIds.add(archived.definition.id);
+    archivedKeys.add(archived.definition.stableKey);
+  }
+  const relatedItemIds = /* @__PURE__ */ new Set();
+  for (const [index, relatedItemId] of item.relatedItemIds.entries()) {
+    if (relatedItemId === item.id || relatedItemIds.has(relatedItemId)) {
+      context.addIssue({
+        code: "custom",
+        message: "Related item IDs must be unique and cannot reference the item itself",
+        path: ["relatedItemIds", index]
+      });
+    }
+    relatedItemIds.add(relatedItemId);
+  }
+  const attachmentIds = /* @__PURE__ */ new Set();
+  for (const [index, attachmentId] of item.attachmentIds.entries()) {
+    if (attachmentIds.has(attachmentId)) {
+      context.addIssue({
+        code: "custom",
+        message: "Attachment IDs must be unique",
+        path: ["attachmentIds", index]
+      });
+    }
+    attachmentIds.add(attachmentId);
+  }
+  for (const [collectionName, values] of [
+    ["templateValues", item.templateValues],
+    ["itemValues", item.itemValues]
+  ]) {
+    for (const [valueIndex, stored] of values.entries()) {
+      for (const reference of referencedEntities(stored.value)) {
+        const valid = reference.kind === "item-reference" ? relatedItemIds.has(reference.itemId) : attachmentIds.has(reference.attachmentId);
+        if (!valid) {
+          context.addIssue({
+            code: "custom",
+            message: "Field references must resolve through the item reference lists",
+            path: [collectionName, valueIndex, "value"]
+          });
+        }
+      }
+    }
+  }
+  const activeKeys = /* @__PURE__ */ new Set([
+    ...item.templateValues.map(({ stableKey }) => stableKey),
+    ...item.itemFields.map(({ stableKey }) => stableKey)
+  ]);
+  const sequenceIds = /* @__PURE__ */ new Set();
+  for (const [index, sequence] of item.copySequences.entries()) {
+    if (sequenceIds.has(sequence.id)) {
+      context.addIssue({
+        code: "custom",
+        message: "Copy sequence IDs must be unique",
+        path: ["copySequences", index, "id"]
+      });
+    }
+    sequenceIds.add(sequence.id);
+    if (sequence.fieldKeys.some((key) => !activeKeys.has(key))) {
+      context.addIssue({
+        code: "custom",
+        message: "Copy sequences may contain only active stable field keys",
+        path: ["copySequences", index, "fieldKeys"]
+      });
+    }
+  }
+});
+var itemPayloadSchema = itemPayloadV1Schema;
+function referencedEntities(value) {
+  if (value.state !== "present")
+    return [];
+  const scalars = value.content.cardinality === "single" ? [value.content.value] : value.content.elements.map(({ value: scalar }) => scalar);
+  const references = [];
+  for (const scalar of scalars) {
+    if (scalar.kind === "item-reference")
+      references.push(scalar);
+    if (scalar.kind === "attachment-reference")
+      references.push(scalar);
+  }
+  return references;
+}
+var vaultPreferencesSchema = external_exports.object({
+  productLabel: nonEmptyTextSchema,
+  executableName: external_exports.string().min(1).max(64).regex(/^[A-Za-z0-9_-]+$/),
+  clipboardClearSeconds: external_exports.number().int().min(1).max(3600),
+  revealHideSeconds: external_exports.number().int().min(1).max(3600),
+  historyRetentionDays: external_exports.number().int().min(1).max(36500),
+  telemetryEnabled: external_exports.literal(false)
+}).strict();
+
+// ../../packages/schemas/dist/local-vault.js
+var localVaultFormatSchema = external_exports.literal("kavrix-local-vault");
+var CURRENT_LOCAL_VAULT_VERSION = 2;
+var localVaultVersionSchema = external_exports.literal(CURRENT_LOCAL_VAULT_VERSION);
+var MAX_LOCAL_RECOVERY_SLOTS = 32;
+var localRecoveryKeySlotSchema = keySlotSchema.refine((slot) => slot.type === "recovery-key", { error: "Local recovery slots require recovery-key material" });
+var localVaultValueSchema = external_exports.object({
+  value: maxTextBytesSchema,
+  updatedAt: timestampSchema
+}).strict();
+var localVaultPayloadSchema = external_exports.object({
+  records: external_exports.record(external_exports.string().min(1).max(256), localVaultValueSchema)
+}).strict().superRefine((payload, context) => {
+  if (Object.keys(payload.records).length > 1e4) {
+    context.addIssue({
+      code: "custom",
+      message: "Local vault contains too many credentials",
+      path: ["records"]
+    });
+  }
+});
+var localVaultDocumentSchema = external_exports.object({
+  format: localVaultFormatSchema,
+  version: localVaultVersionSchema,
+  id: vaultIdSchema,
+  schemaVersion: supportedSchemaVersionSchema,
+  cryptographicVersion: supportedCryptographicVersionSchema,
+  currentKeyVersion: keyVersionSchema,
+  keySlot: keySlotSchema,
+  recoverySlots: external_exports.array(localRecoveryKeySlotSchema).max(MAX_LOCAL_RECOVERY_SLOTS).default([]),
+  revision: vaultRevisionSchema,
+  encryptedPayload: aeadEnvelopeSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+}).strict().superRefine((document, context) => {
+  if (document.schemaVersion !== CURRENT_SCHEMA_VERSION) {
+    context.addIssue({
+      code: "custom",
+      message: "Unsupported local vault schema version",
+      path: ["schemaVersion"]
+    });
+  }
+  if (document.cryptographicVersion !== CURRENT_CRYPTOGRAPHIC_VERSION) {
+    context.addIssue({
+      code: "custom",
+      message: "Unsupported local vault cryptographic version",
+      path: ["cryptographicVersion"]
+    });
+  }
+  if (document.keySlot.type !== "portable-key") {
+    context.addIssue({
+      code: "custom",
+      message: "Local vaults require a portable-key unlock slot",
+      path: ["keySlot", "type"]
+    });
+  } else {
+    if (document.keySlot.state !== "active") {
+      context.addIssue({
+        code: "custom",
+        message: "Local vault unlock slot must be active",
+        path: ["keySlot", "state"]
+      });
+    }
+    if (document.keySlot.keyVersion !== document.currentKeyVersion) {
+      context.addIssue({
+        code: "custom",
+        message: "Local vault key versions do not agree",
+        path: ["keySlot", "keyVersion"]
+      });
+    }
+    if (document.keySlot.wrappedRootKey.aad.vaultId !== document.id) {
+      context.addIssue({
+        code: "custom",
+        message: "Local vault key slot belongs to another vault",
+        path: ["keySlot", "wrappedRootKey", "aad", "vaultId"]
+      });
+    }
+  }
+  const slotIds = /* @__PURE__ */ new Set([document.keySlot.id]);
+  for (const [index, slot] of document.recoverySlots.entries()) {
+    if (slotIds.has(slot.id)) {
+      context.addIssue({
+        code: "custom",
+        message: "Local key slot IDs must be unique",
+        path: ["recoverySlots", index, "id"]
+      });
+    }
+    slotIds.add(slot.id);
+    if (slot.keyVersion !== document.currentKeyVersion) {
+      context.addIssue({
+        code: "custom",
+        message: "Local recovery slot key version does not match the vault",
+        path: ["recoverySlots", index, "keyVersion"]
+      });
+    }
+    if (slot.wrappedRootKey.aad.vaultId !== document.id) {
+      context.addIssue({
+        code: "custom",
+        message: "Local recovery slot belongs to another vault",
+        path: ["recoverySlots", index, "wrappedRootKey", "aad", "vaultId"]
+      });
+    }
+    if (slot.wrappedRootKey.aad.schemaVersion !== document.schemaVersion) {
+      context.addIssue({
+        code: "custom",
+        message: "Local recovery slot schema version does not match the vault",
+        path: ["recoverySlots", index, "wrappedRootKey", "aad", "schemaVersion"]
+      });
+    }
+    if (slot.state !== "active" && slot.state !== "revoked") {
+      context.addIssue({
+        code: "custom",
+        message: "Local recovery slots must be active or revoked",
+        path: ["recoverySlots", index, "state"]
+      });
+    }
+  }
+  const aad = document.encryptedPayload.aad;
+  if (aad.revision === void 0 || aad.metadataDigest === void 0 || aad.revision !== document.revision) {
+    context.addIssue({
+      code: "custom",
+      message: "Local vault payload metadata binding is invalid",
+      path: ["encryptedPayload", "aad"]
+    });
+  }
+  if (aad.vaultId !== document.id || aad.entityId !== document.id || aad.schemaVersion !== document.schemaVersion || aad.keyVersion !== document.currentKeyVersion) {
+    context.addIssue({
+      code: "custom",
+      message: "Local vault payload has invalid associated data",
+      path: ["encryptedPayload", "aad"]
+    });
+  }
+});
+
+// ../../packages/schemas/dist/authorization.js
+var API_SCOPE_VALUES = Object.freeze([
+  "sync:read",
+  "sync:write",
+  "device:manage"
+]);
+var MIN_API_SCOPES = 1;
+var MAX_API_SCOPES = API_SCOPE_VALUES.length;
+var apiScopeSchema = external_exports.enum(API_SCOPE_VALUES);
+var apiScopesSchema = external_exports.array(apiScopeSchema).min(MIN_API_SCOPES).max(MAX_API_SCOPES).superRefine((scopes, context) => {
+  if (new Set(scopes).size !== scopes.length) {
+    context.addIssue({
+      code: "custom",
+      message: "API scopes must be unique"
+    });
+  }
+});
+
+// ../../packages/schemas/dist/sync.js
+var MIN_IDEMPOTENCY_KEY_CHARS = 16;
+var MAX_IDEMPOTENCY_KEY_CHARS = 256;
+var syncEntityTypeSchema = external_exports.enum(["vault", "group", "item", "attachment"]);
+var syncOperationSchema = external_exports.enum(["upsert", "tombstone", "restore", "purge"]);
+var changeRecordBaseSchema = external_exports.object({
+  id: changeIdSchema,
+  vaultId: vaultIdSchema,
+  serverSequence: changeSequenceSchema,
+  recordRevision: recordRevisionSchema,
+  operation: syncOperationSchema,
+  ciphertextHash: sha256DigestSchema.optional(),
+  createdAt: timestampSchema
+}).strict();
+var changeRecordSchema = external_exports.discriminatedUnion("entityType", [
+  changeRecordBaseSchema.extend({
+    entityType: external_exports.literal("vault"),
+    entityId: vaultIdSchema
+  }),
+  changeRecordBaseSchema.extend({
+    entityType: external_exports.literal("group"),
+    entityId: groupIdSchema
+  }),
+  changeRecordBaseSchema.extend({
+    entityType: external_exports.literal("item"),
+    entityId: itemIdSchema
+  }),
+  changeRecordBaseSchema.extend({
+    entityType: external_exports.literal("attachment"),
+    entityId: attachmentIdSchema
+  })
+]).superRefine((change, context) => {
+  if (change.serverSequence === 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Change records require a positive server sequence",
+      path: ["serverSequence"]
+    });
+  }
+  if (change.operation !== "purge" && change.ciphertextHash === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Non-purge changes require the applicable content hash",
+      path: ["ciphertextHash"]
+    });
+  }
+  if (change.entityType === "vault" && change.entityId !== change.vaultId) {
+    context.addIssue({
+      code: "custom",
+      message: "A vault change must identify its containing vault",
+      path: ["entityId"]
+    });
+  }
+});
+var publicDeviceRecordObjectSchema = external_exports.object({
+  id: deviceIdSchema,
+  vaultId: vaultIdSchema,
+  schemaVersion: supportedSchemaVersionSchema,
+  tokenVersion: supportedTokenVersionSchema,
+  encryptedLabel: encryptedDeviceLabelSchema.optional(),
+  scopes: apiScopesSchema,
+  createdAt: timestampSchema,
+  lastSeenAt: timestampSchema.optional(),
+  revokedAt: timestampSchema.optional()
+}).strict();
+function validateDeviceBinding(device, context) {
+  if (device.encryptedLabel !== void 0 && (device.encryptedLabel.aad.vaultId !== device.vaultId || device.encryptedLabel.aad.schemaVersion !== device.schemaVersion || device.encryptedLabel.aad.entityType !== "device-label" || device.encryptedLabel.aad.entityId !== device.id)) {
+    context.addIssue({
+      code: "custom",
+      message: "Encrypted device label has invalid associated data",
+      path: ["encryptedLabel", "aad"]
+    });
+  }
+}
+var publicDeviceRecordSchema = publicDeviceRecordObjectSchema.superRefine(validateDeviceBinding);
+var deviceRecordSchema = publicDeviceRecordObjectSchema.extend({ tokenHash: sha256DigestSchema }).superRefine(validateDeviceBinding);
+var outboundObservationKindSchema = external_exports.enum([
+  "generic-push",
+  "template-publication"
+]);
+var outboundObservationContentObjectSchema = external_exports.object({
+  version: external_exports.literal(1),
+  kind: outboundObservationKindSchema,
+  batchIdempotencyKey: external_exports.string().min(MIN_IDEMPOTENCY_KEY_CHARS).max(MAX_IDEMPOTENCY_KEY_CHARS),
+  requestHash: sha256DigestSchema,
+  responseHash: sha256DigestSchema,
+  responseVaultRevision: vaultRevisionSchema,
+  replayFromServerSequence: changeSequenceSchema,
+  requiredThroughServerSequence: changeSequenceSchema
+}).strict();
+function validateObservationSequence(observation, context) {
+  if (observation.requiredThroughServerSequence < observation.replayFromServerSequence) {
+    context.addIssue({
+      code: "custom",
+      message: "The required sequence cannot precede the replay start",
+      path: ["requiredThroughServerSequence"]
+    });
+  }
+}
+var outboundObservationContentSchema = outboundObservationContentObjectSchema.superRefine(validateObservationSequence);
+var outboundObservationSchema = outboundObservationContentObjectSchema.extend({ observationId: sha256DigestSchema }).strict().superRefine(validateObservationSequence);
+var protectedLocalDeviceStateSchema = external_exports.object({
+  version: external_exports.literal(2),
+  vaultId: vaultIdSchema,
+  deviceId: deviceIdSchema,
+  highestSeenVaultRevision: vaultRevisionSchema,
+  updatedAt: timestampSchema,
+  outboundObservation: outboundObservationSchema.optional(),
+  lastCompletedObservationId: sha256DigestSchema.optional()
+}).strict().superRefine((state, context) => {
+  if (state.outboundObservation !== void 0 && state.outboundObservation.responseVaultRevision > state.highestSeenVaultRevision) {
+    context.addIssue({
+      code: "custom",
+      message: "The protected anchor must include the observed response revision",
+      path: ["highestSeenVaultRevision"]
+    });
+  }
+});
+var tombstoneRecordBaseSchema = external_exports.object({
+  vaultId: vaultIdSchema,
+  state: external_exports.enum(["deleted", "restored"]),
+  tombstoneRevision: recordRevisionSchema,
+  lastRecordRevision: recordRevisionSchema,
+  lastCiphertextHash: sha256DigestSchema,
+  deletedAt: timestampSchema,
+  restoredAt: timestampSchema.optional(),
+  purgeAfter: timestampSchema.optional()
+}).strict();
+var tombstoneRecordSchema = external_exports.discriminatedUnion("entityType", [
+  tombstoneRecordBaseSchema.extend({
+    entityType: external_exports.literal("vault"),
+    entityId: vaultIdSchema
+  }),
+  tombstoneRecordBaseSchema.extend({
+    entityType: external_exports.literal("group"),
+    entityId: groupIdSchema
+  }),
+  tombstoneRecordBaseSchema.extend({
+    entityType: external_exports.literal("item"),
+    entityId: itemIdSchema
+  }),
+  tombstoneRecordBaseSchema.extend({
+    entityType: external_exports.literal("attachment"),
+    entityId: attachmentIdSchema
+  })
+]).superRefine((tombstone, context) => {
+  if (tombstone.tombstoneRevision <= tombstone.lastRecordRevision) {
+    context.addIssue({
+      code: "custom",
+      message: "Tombstone revision must be newer than the deleted record",
+      path: ["tombstoneRevision"]
+    });
+  }
+  if (tombstone.entityType === "vault" && tombstone.entityId !== tombstone.vaultId) {
+    context.addIssue({
+      code: "custom",
+      message: "A vault tombstone must identify its containing vault",
+      path: ["entityId"]
+    });
+  }
+  if (tombstone.state === "restored" && tombstone.restoredAt === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Restored tombstones require a restoration timestamp",
+      path: ["restoredAt"]
+    });
+  }
+  if (tombstone.state === "deleted" && tombstone.restoredAt !== void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Deleted tombstones cannot have a restoration timestamp",
+      path: ["restoredAt"]
+    });
+  }
+  if (tombstone.state === "restored" && tombstone.purgeAfter !== void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Restored tombstones cannot remain scheduled for purge",
+      path: ["purgeAfter"]
+    });
+  }
+});
+var opaqueMutationSchema = external_exports.discriminatedUnion("entityType", [
+  external_exports.object({
+    entityType: external_exports.literal("vault"),
+    expectedVaultRevision: vaultRevisionSchema.nullable(),
+    idempotencyKey: external_exports.string().min(MIN_IDEMPOTENCY_KEY_CHARS).max(MAX_IDEMPOTENCY_KEY_CHARS),
+    record: vaultRecordSchema
+  }).strict(),
+  external_exports.object({
+    entityType: external_exports.literal("group"),
+    expectedRecordRevision: recordRevisionSchema.nullable(),
+    idempotencyKey: external_exports.string().min(MIN_IDEMPOTENCY_KEY_CHARS).max(MAX_IDEMPOTENCY_KEY_CHARS),
+    record: encryptedGroupRecordSchema
+  }).strict(),
+  external_exports.object({
+    entityType: external_exports.literal("item"),
+    expectedRecordRevision: recordRevisionSchema.nullable(),
+    idempotencyKey: external_exports.string().min(MIN_IDEMPOTENCY_KEY_CHARS).max(MAX_IDEMPOTENCY_KEY_CHARS),
+    record: encryptedItemRecordSchema
+  }).strict()
+]);
+var attachmentStreamStartInputSchema = external_exports.object({
+  version: external_exports.literal(1),
+  idempotencyKey: external_exports.string().min(MIN_IDEMPOTENCY_KEY_CHARS).max(MAX_IDEMPOTENCY_KEY_CHARS),
+  expectedAttachmentRevision: recordRevisionSchema.nullable(),
+  header: persistedAttachmentHeaderRecordSchema
+}).strict().superRefine((input, context) => {
+  const expectedNewRevision = input.expectedAttachmentRevision === null ? 0 : input.expectedAttachmentRevision + 1;
+  if (input.header.recordRevision !== expectedNewRevision) {
+    context.addIssue({
+      code: "custom",
+      message: "Staged header revision must immediately follow the expected attachment",
+      path: ["header", "recordRevision"]
+    });
+  }
+  if (attachmentHeaderContentHash(input.header) !== input.header.contentHash) {
+    context.addIssue({
+      code: "custom",
+      message: "Staged attachment headers require their exact canonical content hash",
+      path: ["header", "contentHash"]
+    });
+  }
+});
+var attachmentStreamProgressCountersSchema = external_exports.object({
+  version: external_exports.literal(1),
+  nextChunkIndex: external_exports.number().int().nonnegative().max(MAX_ATTACHMENT_CHUNKS),
+  totalPlaintextBytes: external_exports.number().int().nonnegative().max(MAX_ATTACHMENT_STREAM_PLAINTEXT_BYTES),
+  totalCiphertextBytes: external_exports.number().int().nonnegative().max(MAX_ATTACHMENT_STREAM_CIPHERTEXT_BYTES)
+});
+var attachmentStreamProgressSchema = external_exports.discriminatedUnion("state", [
+  attachmentStreamProgressCountersSchema.extend({
+    state: external_exports.literal("empty"),
+    nextChunkIndex: external_exports.literal(0),
+    totalPlaintextBytes: external_exports.literal(0),
+    totalCiphertextBytes: external_exports.literal(0)
+  }).strict(),
+  attachmentStreamProgressCountersSchema.extend({
+    state: external_exports.literal("writing"),
+    nextChunkIndex: external_exports.number().int().positive().max(MAX_ATTACHMENT_CHUNKS),
+    lastChunkIndex: external_exports.number().int().nonnegative().max(MAX_ATTACHMENT_CHUNKS - 1),
+    lastChunkCiphertextHash: sha256DigestSchema,
+    lastChunkPlaintextBytes: external_exports.number().int().nonnegative().max(MAX_ATTACHMENT_CHUNK_PLAINTEXT_BYTES)
+  }).strict(),
+  attachmentStreamProgressCountersSchema.extend({
+    state: external_exports.literal("ready-to-finalize"),
+    nextChunkIndex: external_exports.number().int().positive().max(MAX_ATTACHMENT_CHUNKS),
+    lastChunkIndex: external_exports.number().int().nonnegative().max(MAX_ATTACHMENT_CHUNKS - 1),
+    lastChunkCiphertextHash: sha256DigestSchema,
+    lastChunkPlaintextBytes: external_exports.number().int().nonnegative().max(MAX_ATTACHMENT_CHUNK_PLAINTEXT_BYTES)
+  }).strict()
+]).superRefine((progress, context) => {
+  if (progress.state === "empty")
+    return;
+  if (progress.state === "writing" && progress.nextChunkIndex === MAX_ATTACHMENT_CHUNKS) {
+    context.addIssue({
+      code: "custom",
+      message: "The maximum chunk count requires final-chunk state",
+      path: ["state"]
+    });
+  }
+  if (progress.lastChunkIndex !== progress.nextChunkIndex - 1) {
+    context.addIssue({
+      code: "custom",
+      message: "Last chunk index must immediately precede the next chunk index",
+      path: ["lastChunkIndex"]
+    });
+  }
+  if (progress.totalCiphertextBytes !== progress.totalPlaintextBytes + progress.nextChunkIndex * SECRETSTREAM_CHUNK_OVERHEAD_BYTES) {
+    context.addIssue({
+      code: "custom",
+      message: "Staging byte totals must include exactly one overhead per chunk",
+      path: ["totalCiphertextBytes"]
+    });
+  }
+});
+var attachmentStreamFinalizeInputSchema = external_exports.object({
+  version: external_exports.literal(1),
+  record: encryptedAttachmentRecordSchema
+}).strict();
+var syncCursorSchema = external_exports.object({
+  vaultId: vaultIdSchema,
+  serverSequence: changeSequenceSchema,
+  highestSeenVaultRevision: vaultRevisionSchema
+}).strict();
+var syncStateSchema = external_exports.enum([
+  "synced",
+  "offline",
+  "syncing",
+  "conflict",
+  "error"
+]);
+var syncConflictResolutionStrategySchema = external_exports.enum([
+  "keep-local",
+  "accept-remote"
+]);
+var syncConflictResolutionSchema = external_exports.object({
+  version: external_exports.literal(1),
+  strategy: syncConflictResolutionStrategySchema,
+  currentRevision: external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  replacementIdempotencyKey: external_exports.string().nullable(),
+  resolvedAt: timestampSchema
+}).strict();
+
+// ../../packages/schemas/dist/api.js
+var healthResponseSchema = external_exports.object({ status: external_exports.literal("ok") }).strict();
+var readinessResponseSchema = external_exports.object({ status: external_exports.enum(["ready", "not_ready"]) }).strict();
+var CONTROL_LIST_CURSOR_VERSION = 1;
+var DEFAULT_CONTROL_LIST_PAGE_SIZE = 50;
+var MAX_CONTROL_LIST_PAGE_SIZE = 200;
+var MAX_CONTROL_LIST_CURSOR_CHARS = 512;
+var MAX_SYNC_PUSH_MUTATIONS = 100;
+var MAX_TEMPLATE_MIGRATION_RESULTS = 100;
+var MAX_SYNC_PULL_PAGE_CHANGES = 500;
+var controlListCursorPayloadBaseSchema = external_exports.object({
+  version: external_exports.literal(CONTROL_LIST_CURSOR_VERSION),
+  vaultId: vaultIdSchema,
+  createdAt: timestampSchema
+}).strict();
+var controlListCursorPayloadSchema = external_exports.discriminatedUnion("resource", [
+  controlListCursorPayloadBaseSchema.extend({
+    resource: external_exports.literal("invites"),
+    id: inviteIdSchema
+  }).strict(),
+  controlListCursorPayloadBaseSchema.extend({
+    resource: external_exports.literal("devices"),
+    id: deviceIdSchema
+  }).strict()
+]);
+var boundedControlListCursorSchema = external_exports.string().min(1).max(MAX_CONTROL_LIST_CURSOR_CHARS).pipe(base64UrlSchema).brand();
+function encodeControlListCursor(payload) {
+  const parsedPayload = controlListCursorPayloadSchema.parse(payload);
+  return boundedControlListCursorSchema.parse(Buffer.from(canonicalJson(parsedPayload), "utf8").toString("base64url"));
+}
+function decodeCanonicalControlListCursor(cursor) {
+  try {
+    const parsedCursor = boundedControlListCursorSchema.parse(cursor);
+    const json = new TextDecoder("utf-8", { fatal: true }).decode(Buffer.from(parsedCursor, "base64url"));
+    const payload = controlListCursorPayloadSchema.parse(JSON.parse(json));
+    if (encodeControlListCursor(payload) !== parsedCursor) {
+      throw new TypeError("Noncanonical control-list cursor");
+    }
+    return payload;
+  } catch {
+    throw new TypeError("Invalid control-list cursor");
+  }
+}
+function decodeControlListCursor(cursor) {
+  return decodeCanonicalControlListCursor(cursor);
+}
+var controlListCursorSchema = boundedControlListCursorSchema.superRefine((cursor, context) => {
+  try {
+    decodeCanonicalControlListCursor(cursor);
+  } catch {
+    context.addIssue({
+      code: "custom",
+      message: "Control-list cursor is malformed or noncanonical"
+    });
+  }
+});
+var apiBearerTokenSchema = external_exports.string().length(43).regex(/^[A-Za-z0-9_-]+$/, "Bearer tokens use canonical unpadded base64url").refine((value) => Buffer.from(value, "base64url").toString("base64url") === value, {
+  error: "Bearer tokens use canonical unpadded base64url"
+}).brand();
+var apiErrorResponseSchema = external_exports.object({
+  error: external_exports.object({
+    code: external_exports.string().min(1).max(64),
+    message: external_exports.string().min(1).max(256),
+    conflict: external_exports.object({
+      entityType: external_exports.enum(["vault", "group", "item", "attachment"]),
+      entityId: external_exports.string().min(1).max(128),
+      expectedRevision: external_exports.number().int().nonnegative().nullable(),
+      currentRevision: external_exports.number().int().nonnegative().nullable()
+    }).strict().optional()
+  }).strict()
+}).strict();
+var inviteIssueRequestSchema = external_exports.object({
+  scopes: apiScopesSchema,
+  expiresInSeconds: external_exports.number().int().min(60).max(86400)
+}).strict();
+var inviteIssueResponseSchema = external_exports.object({
+  inviteId: inviteIdSchema,
+  inviteToken: apiBearerTokenSchema,
+  expiresAt: timestampSchema
+}).strict();
+var publicInviteRecordSchema = external_exports.object({
+  id: inviteIdSchema,
+  vaultId: vaultIdSchema,
+  issuedByDeviceId: deviceIdSchema,
+  scopes: apiScopesSchema,
+  state: external_exports.enum(["active", "redeemed", "revoked", "expired"]),
+  createdAt: timestampSchema,
+  expiresAt: timestampSchema,
+  consumedAt: timestampSchema.optional(),
+  revokedAt: timestampSchema.optional()
+}).strict().superRefine((invite, context) => {
+  if (invite.state === "redeemed" !== (invite.consumedAt !== void 0)) {
+    context.addIssue({
+      code: "custom",
+      path: ["consumedAt"],
+      message: "Only redeemed invites carry a consumption timestamp"
+    });
+  }
+  if (invite.state === "revoked" !== (invite.revokedAt !== void 0)) {
+    context.addIssue({
+      code: "custom",
+      path: ["revokedAt"],
+      message: "Only revoked invites carry a revocation timestamp"
+    });
+  }
+});
+var inviteListPageResponseSchema = external_exports.object({
+  invites: external_exports.array(publicInviteRecordSchema).max(MAX_CONTROL_LIST_PAGE_SIZE),
+  nextCursor: controlListCursorSchema.nullable()
+}).strict().superRefine((page, context) => {
+  validateControlListPage("invites", page.invites, page.nextCursor, context);
+});
+var vaultInvitePathSchema = external_exports.object({ vaultId: vaultIdSchema, inviteId: inviteIdSchema }).strict();
+var inviteRedeemResponseSchema = external_exports.object({
+  vaultId: vaultIdSchema,
+  expiresAt: timestampSchema,
+  vault: vaultRecordSchema
+}).strict().refine((response) => response.vault.id === response.vaultId, {
+  path: ["vault", "id"],
+  error: "Redeemed vaults must match the invite vault"
+});
+var enrollmentCompleteRequestSchema = external_exports.object({
+  vaultId: vaultIdSchema,
+  deviceId: deviceIdSchema,
+  schemaVersion: supportedSchemaVersionSchema,
+  encryptedLabel: encryptedDeviceLabelSchema.optional()
+}).strict().superRefine((request, context) => {
+  validateDeviceLabelBinding(request.encryptedLabel, request.vaultId, request.deviceId, request.schemaVersion, context, ["encryptedLabel", "aad"]);
+});
+var enrollmentCompleteResponseSchema = external_exports.object({
+  vaultId: vaultIdSchema,
+  deviceId: deviceIdSchema
+}).strict();
+var apiSessionResponseSchema = external_exports.object({
+  vaultId: vaultIdSchema,
+  deviceId: deviceIdSchema,
+  scopes: apiScopesSchema
+}).strict();
+var vaultBootstrapRequestSchema = external_exports.object({
+  vault: vaultRecordSchema,
+  device: external_exports.object({
+    id: deviceIdSchema,
+    schemaVersion: supportedSchemaVersionSchema,
+    encryptedLabel: encryptedDeviceLabelSchema.optional()
+  }).strict()
+}).strict().superRefine((request, context) => {
+  if (request.vault.revision !== 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["vault", "revision"],
+      message: "Initial vaults must start at revision zero"
+    });
+  }
+  if (request.vault.createdAt !== request.vault.updatedAt) {
+    context.addIssue({
+      code: "custom",
+      path: ["vault", "updatedAt"],
+      message: "Initial vault timestamps must match"
+    });
+  }
+  if (request.device.schemaVersion !== request.vault.schemaVersion) {
+    context.addIssue({
+      code: "custom",
+      path: ["device", "schemaVersion"],
+      message: "The first device and vault schema versions must match"
+    });
+  }
+  validateDeviceLabelBinding(request.device.encryptedLabel, request.vault.id, request.device.id, request.device.schemaVersion, context, ["device", "encryptedLabel", "aad"]);
+});
+var vaultBootstrapResponseSchema = external_exports.object({
+  vaultId: vaultIdSchema,
+  deviceId: deviceIdSchema
+}).strict();
+var deviceListPageResponseSchema = external_exports.object({
+  devices: external_exports.array(publicDeviceRecordSchema).max(MAX_CONTROL_LIST_PAGE_SIZE),
+  nextCursor: controlListCursorSchema.nullable()
+}).strict().superRefine((page, context) => {
+  validateControlListPage("devices", page.devices, page.nextCursor, context);
+});
+var vaultPathSchema = external_exports.object({ vaultId: vaultIdSchema }).strict();
+var vaultDevicePathSchema = external_exports.object({ vaultId: vaultIdSchema, deviceId: deviceIdSchema }).strict();
+var vaultKeySlotPathSchema = external_exports.object({ vaultId: vaultIdSchema, slotId: keySlotIdSchema }).strict();
+var vaultKeySlotUpdateRequestSchema = external_exports.object({
+  expectedVaultRevision: vaultRevisionSchema,
+  idempotencyKey: external_exports.string().min(MIN_IDEMPOTENCY_KEY_CHARS).max(MAX_IDEMPOTENCY_KEY_CHARS),
+  record: vaultRecordSchema,
+  /** New slot mutations carry an opaque encrypted audit sidecar. */
+  audit: encryptedAuditRecordSchema.optional()
+}).strict().refine((value) => value.record.revision === value.expectedVaultRevision + 1, {
+  path: ["record", "revision"],
+  error: "Key-slot updates must advance the vault revision exactly once"
+});
+var decimalIntegerQuerySchema = external_exports.string().regex(/^(?:0|[1-9][0-9]*)$/, "Must be a canonical nonnegative integer").transform((value, context) => {
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed)) {
+    context.addIssue({
+      code: "custom",
+      message: "Integer is outside the safe range"
+    });
+    return external_exports.NEVER;
+  }
+  return parsed;
+});
+var numericControlListPageLimitSchema = external_exports.number().int().min(1).max(MAX_CONTROL_LIST_PAGE_SIZE);
+var controlListPageOptionsSchema = external_exports.object({
+  limit: numericControlListPageLimitSchema.default(DEFAULT_CONTROL_LIST_PAGE_SIZE),
+  cursor: controlListCursorSchema.optional()
+}).strict();
+var controlListPageLimitQuerySchema = decimalIntegerQuerySchema.pipe(numericControlListPageLimitSchema);
+var controlListPageQuerySchema = external_exports.object({
+  limit: controlListPageLimitQuerySchema.optional(),
+  cursor: controlListCursorSchema.optional()
+}).strict().transform((query) => controlListPageOptionsSchema.parse(query));
+var attachmentTransferPathSchema = external_exports.object({
+  vaultId: vaultIdSchema,
+  groupId: groupIdSchema,
+  itemId: itemIdSchema,
+  attachmentId: attachmentIdSchema
+}).strict();
+var attachmentChunkPathSchema = attachmentTransferPathSchema.extend({ chunkIndex: decimalIntegerQuerySchema }).strict().refine((path) => path.chunkIndex < MAX_ATTACHMENT_CHUNKS, {
+  path: ["chunkIndex"],
+  error: "Attachment chunk index is outside the canonical bound"
+});
+var attachmentChunkStageRequestSchema = external_exports.object({
+  start: attachmentStreamStartInputSchema,
+  chunk: persistedAttachmentChunkRecordSchema
+}).strict().superRefine((request, context) => {
+  validateAttachmentTransportIdentity(request.start, request.chunk.record, request.chunk.recordRevision, context, ["chunk"]);
+});
+var attachmentFinalizeRequestSchema = external_exports.object({
+  start: attachmentStreamStartInputSchema,
+  finalize: attachmentStreamFinalizeInputSchema
+}).strict().superRefine((request, context) => {
+  validateAttachmentTransportIdentity(request.start, request.finalize.record, request.finalize.record.recordRevision, context, ["finalize", "record"]);
+});
+var syncPullQuerySchema = external_exports.object({
+  serverSequence: decimalIntegerQuerySchema.default(0),
+  highestSeenVaultRevision: decimalIntegerQuerySchema,
+  limit: decimalIntegerQuerySchema.default(100)
+}).strict().transform((value) => ({
+  serverSequence: changeSequenceSchema.parse(value.serverSequence),
+  highestSeenVaultRevision: vaultRevisionSchema.parse(value.highestSeenVaultRevision),
+  limit: value.limit
+})).refine((value) => value.limit >= 1 && value.limit <= MAX_SYNC_PULL_PAGE_CHANGES, {
+  path: ["limit"],
+  error: "Sync pull limits must be between 1 and 500"
+});
+var opaqueSyncRecordSchema = external_exports.union([
+  vaultRecordSchema,
+  encryptedGroupRecordSchema,
+  encryptedItemRecordSchema,
+  encryptedAttachmentRecordSchema,
+  tombstoneRecordSchema
+]);
+var syncPulledChangeSchema = external_exports.object({
+  change: changeRecordSchema,
+  record: opaqueSyncRecordSchema.nullable()
+}).strict().superRefine((pulled, context) => {
+  const { change, record } = pulled;
+  if (change.operation === "purge") {
+    if (record !== null) {
+      context.addIssue({
+        code: "custom",
+        path: ["record"],
+        message: "Purged changes cannot include a record"
+      });
+    }
+    return;
+  }
+  if (record === null || syncRecordVaultId(record) !== change.vaultId || syncRecordEntityType(record) !== change.entityType || syncRecordId(record) !== change.entityId || syncRecordRevision(record) !== change.recordRevision) {
+    context.addIssue({
+      code: "custom",
+      path: ["record"],
+      message: "Pulled records must be bound to their change metadata"
+    });
+    return;
+  }
+  if (change.operation === "tombstone" && (!isTombstoneRecord(record) || record.state !== "deleted")) {
+    context.addIssue({
+      code: "custom",
+      path: ["record"],
+      message: "Tombstone changes require a deleted tombstone record"
+    });
+  }
+  if ((change.operation === "upsert" || change.operation === "restore") && !isCurrentOpaqueRecord(record)) {
+    context.addIssue({
+      code: "custom",
+      path: ["record"],
+      message: "Upsert and restore changes require a current encrypted record"
+    });
+  }
+});
+var syncPullResponseSchema = external_exports.object({
+  vaultId: vaultIdSchema,
+  serverVaultRevision: vaultRevisionSchema,
+  changes: external_exports.array(syncPulledChangeSchema).max(MAX_SYNC_PULL_PAGE_CHANGES),
+  nextCursor: syncCursorSchema,
+  hasMore: external_exports.boolean()
+}).strict().superRefine((page, context) => {
+  if (page.nextCursor.vaultId !== page.vaultId || page.nextCursor.highestSeenVaultRevision !== page.serverVaultRevision) {
+    context.addIssue({
+      code: "custom",
+      path: ["nextCursor"],
+      message: "The next cursor must be bound to the returned vault revision"
+    });
+  }
+  if (page.changes.some(({ change }) => change.vaultId !== page.vaultId)) {
+    context.addIssue({
+      code: "custom",
+      path: ["changes"],
+      message: "All changes must belong to the response vault"
+    });
+  }
+  if (page.hasMore && page.changes.length === 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["hasMore"],
+      message: "A nonterminal page must contain at least one change"
+    });
+  }
+});
+var syncPushRequestSchema = external_exports.object({
+  vaultId: vaultIdSchema,
+  batchIdempotencyKey: external_exports.string().min(MIN_IDEMPOTENCY_KEY_CHARS).max(MAX_IDEMPOTENCY_KEY_CHARS),
+  mutations: external_exports.array(opaqueMutationSchema).min(1).max(MAX_SYNC_PUSH_MUTATIONS)
+}).strict().superRefine((batch, context) => {
+  const keys = /* @__PURE__ */ new Set();
+  for (const [index, mutation] of batch.mutations.entries()) {
+    if (syncMutationVaultId(mutation) !== batch.vaultId) {
+      context.addIssue({
+        code: "custom",
+        path: ["mutations", index],
+        message: "Every mutation must belong to the batch vault"
+      });
+    }
+    if (keys.has(mutation.idempotencyKey)) {
+      context.addIssue({
+        code: "custom",
+        path: ["mutations", index, "idempotencyKey"],
+        message: "Mutation idempotency keys must be unique within a batch"
+      });
+    }
+    keys.add(mutation.idempotencyKey);
+    const expected = mutation.entityType === "vault" ? mutation.expectedVaultRevision : mutation.expectedRecordRevision;
+    const revision = mutation.entityType === "vault" ? mutation.record.revision : mutation.record.recordRevision;
+    if (revision !== (expected === null ? 0 : expected + 1)) {
+      context.addIssue({
+        code: "custom",
+        path: ["mutations", index, "record"],
+        message: "Mutations must advance their expected revision exactly once"
+      });
+    }
+  }
+});
+var syncAcceptedPushResultSchema = external_exports.object({
+  status: external_exports.literal("accepted"),
+  idempotencyKey: external_exports.string().min(MIN_IDEMPOTENCY_KEY_CHARS).max(MAX_IDEMPOTENCY_KEY_CHARS),
+  disposition: external_exports.enum(["committed", "duplicate"]),
+  change: changeRecordSchema
+}).strict();
+var syncConflictingPushResultSchema = external_exports.object({
+  status: external_exports.literal("conflict"),
+  idempotencyKey: external_exports.string().min(MIN_IDEMPOTENCY_KEY_CHARS).max(MAX_IDEMPOTENCY_KEY_CHARS),
+  currentRevision: external_exports.union([vaultRevisionSchema, recordRevisionSchema]),
+  current: opaqueSyncRecordSchema.nullable()
+}).strict();
+var syncPushResponseSchema = external_exports.object({
+  vaultId: vaultIdSchema,
+  serverVaultRevision: vaultRevisionSchema,
+  batchIdempotencyKey: external_exports.string().min(MIN_IDEMPOTENCY_KEY_CHARS).max(MAX_IDEMPOTENCY_KEY_CHARS),
+  results: external_exports.array(external_exports.discriminatedUnion("status", [
+    syncAcceptedPushResultSchema,
+    syncConflictingPushResultSchema
+  ])).min(1).max(MAX_SYNC_PUSH_MUTATIONS)
+}).strict();
+var templateMigrationPublicationRequestSchema = syncPushRequestSchema.superRefine((batch, context) => {
+  const entityIds = /* @__PURE__ */ new Set();
+  const itemIds = [];
+  let groupMutation;
+  for (const [index, mutation] of batch.mutations.entries()) {
+    if (mutation.entityType !== "group" && mutation.entityType !== "item") {
+      context.addIssue({
+        code: "custom",
+        path: ["mutations", index, "entityType"],
+        message: "Template migration batches accept only group and item mutations"
+      });
+      continue;
+    }
+    if (mutation.expectedRecordRevision === null || mutation.record.tombstonedAt !== void 0) {
+      context.addIssue({
+        code: "custom",
+        path: ["mutations", index],
+        message: "Template migration mutations must update active current records"
+      });
+    }
+    if (entityIds.has(mutation.record.id)) {
+      context.addIssue({
+        code: "custom",
+        path: ["mutations", index, "record", "id"],
+        message: "Template migration entity IDs must be unique"
+      });
+    }
+    entityIds.add(mutation.record.id);
+    if (mutation.entityType === "group") {
+      if (groupMutation !== void 0) {
+        context.addIssue({
+          code: "custom",
+          path: ["mutations", index],
+          message: "A template migration batch requires exactly one group mutation"
+        });
+      }
+      groupMutation = mutation;
+    } else {
+      itemIds.push(mutation.record.id);
+    }
+  }
+  if (groupMutation === void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["mutations"],
+      message: "A template migration batch requires one group mutation"
+    });
+    return;
+  }
+  if (batch.mutations.at(-1) !== groupMutation) {
+    context.addIssue({
+      code: "custom",
+      path: ["mutations"],
+      message: "The group mutation must be last"
+    });
+  }
+  for (const [index, mutation] of batch.mutations.entries()) {
+    if (mutation.entityType === "item" && mutation.record.groupId !== groupMutation.record.id) {
+      context.addIssue({
+        code: "custom",
+        path: ["mutations", index, "record", "groupId"],
+        message: "Every item must belong to the migrated group"
+      });
+    }
+  }
+  const sortedItemIds = [...itemIds].sort();
+  if (itemIds.some((itemId, index) => itemId !== sortedItemIds[index])) {
+    context.addIssue({
+      code: "custom",
+      path: ["mutations"],
+      message: "Item mutations must be ordered by item ID"
+    });
+  }
+});
+var templateMigrationPublicationResultSchema = external_exports.object({
+  idempotencyKey: external_exports.string().min(MIN_IDEMPOTENCY_KEY_CHARS).max(MAX_IDEMPOTENCY_KEY_CHARS),
+  change: changeRecordSchema
+}).strict().superRefine((result, context) => {
+  if (result.change.entityType !== "group" && result.change.entityType !== "item" || result.change.operation !== "upsert") {
+    context.addIssue({
+      code: "custom",
+      path: ["change"],
+      message: "Template migration results require group or item upserts"
+    });
+  }
+});
+var templateMigrationPublicationResponseSchema = external_exports.object({
+  vaultId: vaultIdSchema,
+  batchIdempotencyKey: external_exports.string().min(MIN_IDEMPOTENCY_KEY_CHARS).max(MAX_IDEMPOTENCY_KEY_CHARS),
+  serverVaultRevision: vaultRevisionSchema,
+  results: external_exports.array(templateMigrationPublicationResultSchema).min(1).max(MAX_TEMPLATE_MIGRATION_RESULTS)
+}).strict().superRefine((response, context) => {
+  const itemIds = [];
+  let groupCount = 0;
+  for (const [index, result] of response.results.entries()) {
+    if (result.change.vaultId !== response.vaultId) {
+      context.addIssue({
+        code: "custom",
+        path: ["results", index, "change", "vaultId"],
+        message: "Every result must belong to the response vault"
+      });
+    }
+    if (index > 0) {
+      const previous = response.results[index - 1];
+      if (previous !== void 0 && result.change.serverSequence !== previous.change.serverSequence + 1) {
+        context.addIssue({
+          code: "custom",
+          path: ["results", index, "change", "serverSequence"],
+          message: "Result sequences must be contiguous"
+        });
+      }
+    }
+    if (result.change.entityType === "group")
+      groupCount += 1;
+    if (result.change.entityType === "item")
+      itemIds.push(result.change.entityId);
+  }
+  if (groupCount !== 1 || response.results.at(-1)?.change.entityType !== "group") {
+    context.addIssue({
+      code: "custom",
+      path: ["results"],
+      message: "Results require exactly one group upsert last"
+    });
+  }
+  const sortedItemIds = [...itemIds].sort();
+  if (itemIds.some((itemId, index) => itemId !== sortedItemIds[index])) {
+    context.addIssue({
+      code: "custom",
+      path: ["results"],
+      message: "Item results must be ordered by item ID"
+    });
+  }
+});
+function validateDeviceLabelBinding(encryptedLabel, vaultId, deviceId, schemaVersion, context, path) {
+  if (encryptedLabel !== void 0 && (encryptedLabel.aad.vaultId !== vaultId || encryptedLabel.aad.entityId !== deviceId || encryptedLabel.aad.schemaVersion !== schemaVersion)) {
+    context.addIssue({
+      code: "custom",
+      path,
+      message: "Encrypted device labels must match their containing request"
+    });
+  }
+}
+function validateControlListPage(resource, rows, nextCursor, context) {
+  const firstRow = rows[0];
+  if (firstRow !== void 0 && rows.some((row) => row.vaultId !== firstRow.vaultId)) {
+    context.addIssue({
+      code: "custom",
+      message: "Every control-list page row must belong to one vault",
+      path: [resource]
+    });
+  }
+  if (nextCursor === null)
+    return;
+  const finalRow = rows.at(-1);
+  if (finalRow === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "An empty control-list page cannot carry a next cursor",
+      path: ["nextCursor"]
+    });
+    return;
+  }
+  let cursorPayload;
+  try {
+    cursorPayload = decodeControlListCursor(nextCursor);
+  } catch {
+    context.addIssue({
+      code: "custom",
+      message: "Control-list page carries an invalid next cursor",
+      path: ["nextCursor"]
+    });
+    return;
+  }
+  if (cursorPayload.resource !== resource || cursorPayload.vaultId !== finalRow.vaultId || cursorPayload.createdAt !== finalRow.createdAt || cursorPayload.id !== finalRow.id) {
+    context.addIssue({
+      code: "custom",
+      message: "Next cursor must identify the final control-list page row",
+      path: ["nextCursor"]
+    });
+  }
+}
+function validateAttachmentTransportIdentity(start, record, recordRevision, context, path) {
+  const header = start.header;
+  const attachmentId = "id" in record ? record.id : record.attachmentId;
+  const keyVersions = "id" in record ? [record.wrappedAttachmentKey.keyVersion, record.encryptedManifest.keyVersion] : [record.keyVersion];
+  if (record.vaultId !== header.record.vaultId || record.groupId !== header.record.groupId || record.itemId !== header.record.itemId || attachmentId !== header.record.attachmentId || record.schemaVersion !== header.record.schemaVersion || keyVersions.some((keyVersion) => keyVersion !== header.record.keyVersion) || recordRevision !== header.recordRevision) {
+    context.addIssue({
+      code: "custom",
+      path,
+      message: "Attachment transport records must share one exact stream identity"
+    });
+  }
+}
+function isTombstoneRecord(record) {
+  return "state" in record;
+}
+function isCurrentOpaqueRecord(record) {
+  return !isTombstoneRecord(record) && (!("tombstonedAt" in record) || record.tombstonedAt === void 0);
+}
+function syncRecordVaultId(record) {
+  return "vaultId" in record ? record.vaultId : record.id;
+}
+function syncRecordId(record) {
+  return isTombstoneRecord(record) ? record.entityId : record.id;
+}
+function syncRecordEntityType(record) {
+  if (isTombstoneRecord(record))
+    return record.entityType;
+  if ("revision" in record)
+    return "vault";
+  if ("itemId" in record)
+    return "attachment";
+  if ("groupId" in record)
+    return "item";
+  return "group";
+}
+function syncRecordRevision(record) {
+  if (isTombstoneRecord(record))
+    return record.tombstoneRevision;
+  return "revision" in record ? record.revision : record.recordRevision;
+}
+function syncMutationVaultId(mutation) {
+  return mutation.entityType === "vault" ? mutation.record.id : mutation.record.vaultId;
+}
+
+// ../../packages/schemas/dist/audit.js
+var keySlotAuditPayloadSchema = external_exports.object({
+  version: external_exports.literal(1),
+  action: external_exports.enum(["create", "revoke"]),
+  slotId: keySlotIdSchema,
+  slotType: external_exports.enum(["portable-key", "passphrase", "recovery-key", "device-key"]),
+  resultingState: external_exports.enum(["active", "revoked"]),
+  keyVersion: keyVersionSchema,
+  actorDeviceId: deviceIdSchema,
+  occurredAt: timestampSchema
+}).strict();
+var auditEventClassSchema = external_exports.enum([
+  "device",
+  "slot",
+  "mutation",
+  "backup",
+  "recovery"
+]);
+var auditEventActionSchema = external_exports.enum([
+  "create",
+  "supersede",
+  "revoke",
+  "queue"
+]);
+var auditEventStateSchema = external_exports.enum([
+  "pending",
+  "active",
+  "superseded",
+  "revoked"
+]);
+var AUDIT_EVENT_ID_BOUNDS = { min: 1, max: 512 };
+var AUDIT_EVENT_SUBJECT_BOUNDS = { min: 1, max: 256 };
+var auditEventIdentifierSchema = external_exports.string().min(AUDIT_EVENT_ID_BOUNDS.min).max(AUDIT_EVENT_ID_BOUNDS.max).regex(/^[A-Za-z0-9][A-Za-z0-9._~:-]*$/u, {
+  message: "Audit event identifiers accept only [A-Za-z0-9._~:-]"
+});
+var auditEventSubjectSchema = external_exports.string().min(AUDIT_EVENT_SUBJECT_BOUNDS.min).max(AUDIT_EVENT_SUBJECT_BOUNDS.max).regex(/^[A-Za-z0-9][A-Za-z0-9._~:-]*$/u, {
+  message: "Audit event subjects accept only [A-Za-z0-9._~:-]"
+});
+var localAuditEventSchema = external_exports.object({
+  version: external_exports.literal(1),
+  eventId: auditEventIdentifierSchema,
+  eventClass: auditEventClassSchema,
+  action: auditEventActionSchema,
+  subject: auditEventSubjectSchema,
+  occurredAt: timestampSchema,
+  keyVersion: keyVersionSchema.optional(),
+  state: auditEventStateSchema.optional(),
+  deviceId: deviceIdSchema.optional(),
+  recordRevision: external_exports.number().int().nonnegative().optional()
+}).strict();
+
+// ../../packages/schemas/dist/backup.js
+var DEFAULT_MAX_BACKUP_RECORDS = 2e6;
+var MAX_SUPPORTED_BACKUP_BYTES = 64 * 1024 * 1024 * 1024;
+var canonical32ByteValueSchema = base64UrlSchema.length(43).refine((value) => Buffer.from(value, "base64url").byteLength === 32, {
+  error: "Value must canonically encode exactly 32 bytes"
+});
+var backupAuthenticationSaltSchema = canonical32ByteValueSchema.brand();
+var backupAuthenticationTagSchema = canonical32ByteValueSchema.brand();
+var backupAuthenticationSchema = external_exports.object({
+  algorithm: external_exports.literal("hkdf-sha256+hmac-sha256"),
+  salt: backupAuthenticationSaltSchema
+}).strict();
+var encryptedBackupHeaderSchema = external_exports.object({
+  type: external_exports.literal("header"),
+  format: external_exports.literal("kavrix-encrypted-backup"),
+  version: external_exports.literal(1),
+  vaultId: vaultIdSchema,
+  schemaVersion: supportedSchemaVersionSchema,
+  createdAt: timestampSchema,
+  authentication: backupAuthenticationSchema
+}).strict();
+var encryptedBackupEntrySchema = external_exports.discriminatedUnion("kind", [
+  external_exports.object({ kind: external_exports.literal("vault"), record: vaultRecordSchema }).strict(),
+  external_exports.object({ kind: external_exports.literal("group"), record: encryptedGroupRecordSchema }).strict(),
+  external_exports.object({ kind: external_exports.literal("item"), record: encryptedItemRecordSchema }).strict(),
+  external_exports.object({ kind: external_exports.literal("attachment"), record: encryptedAttachmentRecordSchema }).strict(),
+  external_exports.object({
+    kind: external_exports.literal("attachment-header"),
+    record: persistedAttachmentHeaderRecordSchema
+  }).strict(),
+  external_exports.object({
+    kind: external_exports.literal("attachment-chunk"),
+    record: persistedAttachmentChunkRecordSchema
+  }).strict(),
+  external_exports.object({ kind: external_exports.literal("audit"), record: encryptedAuditRecordSchema }).strict(),
+  external_exports.object({ kind: external_exports.literal("history"), record: encryptedHistoryRecordSchema }).strict(),
+  external_exports.object({
+    kind: external_exports.literal("tombstone-predecessor"),
+    entityType: external_exports.enum(["group", "item", "attachment"]),
+    record: external_exports.union([
+      encryptedGroupRecordSchema,
+      encryptedItemRecordSchema,
+      encryptedAttachmentRecordSchema
+    ])
+  }).strict().superRefine((entry, context) => {
+    const actualType = "itemId" in entry.record ? "attachment" : "groupId" in entry.record ? "item" : "group";
+    if (entry.entityType !== actualType) {
+      context.addIssue({
+        code: "custom",
+        path: ["entityType"],
+        message: "Tombstone predecessor kind does not match its opaque record"
+      });
+    }
+    if (entry.record.tombstonedAt !== void 0) {
+      context.addIssue({
+        code: "custom",
+        path: ["record", "tombstonedAt"],
+        message: "Tombstone predecessor must be an active opaque record"
+      });
+    }
+  }),
+  external_exports.object({ kind: external_exports.literal("tombstone"), record: tombstoneRecordSchema }).strict()
+]);
+var encryptedBackupFooterSchema = external_exports.object({
+  type: external_exports.literal("footer"),
+  version: external_exports.literal(1),
+  recordCount: external_exports.number().int().positive().max(1e7),
+  transcriptSha256: sha256DigestSchema,
+  authenticationTag: backupAuthenticationTagSchema
+}).strict();
+var backupRecordCountSchema = external_exports.number().int().positive().max(DEFAULT_MAX_BACKUP_RECORDS);
+var backupSubcountSchema = external_exports.number().int().nonnegative().max(DEFAULT_MAX_BACKUP_RECORDS);
+var backupVerificationSchema = external_exports.object({
+  header: encryptedBackupHeaderSchema,
+  restoreSessionId: sha256DigestSchema,
+  recordCount: backupRecordCountSchema,
+  transcriptSha256: sha256DigestSchema,
+  canonicalEntriesSha256: sha256DigestSchema
+}).strict();
+var selectedRestoreSlotSchema = external_exports.object({
+  id: keySlotIdSchema,
+  type: external_exports.enum(["portable-key", "passphrase", "recovery-key"]),
+  keyVersion: keyVersionSchema
+}).strict();
+var verifiedRestoreCountsSchema = external_exports.object({
+  vaults: external_exports.literal(1),
+  groups: backupSubcountSchema,
+  items: backupSubcountSchema,
+  attachments: backupSubcountSchema,
+  attachmentHeaders: backupSubcountSchema,
+  attachmentChunks: backupSubcountSchema,
+  tombstonePredecessors: external_exports.object({
+    groups: backupSubcountSchema,
+    items: backupSubcountSchema,
+    attachments: backupSubcountSchema
+  }).strict(),
+  tombstones: backupSubcountSchema,
+  histories: backupSubcountSchema,
+  audits: backupSubcountSchema
+}).strict();
+var restoreKnownRecordsVerificationV1Schema = external_exports.object({
+  version: external_exports.literal(1),
+  scope: external_exports.literal("known-v1-records"),
+  vaultId: vaultIdSchema,
+  vaultRevision: vaultRevisionSchema,
+  restoreSessionId: sha256DigestSchema,
+  transcriptSha256: sha256DigestSchema,
+  canonicalEntriesSha256: sha256DigestSchema,
+  recordCount: backupRecordCountSchema,
+  selectedSlot: selectedRestoreSlotSchema,
+  verified: verifiedRestoreCountsSchema
+}).strict().superRefine((receipt, context) => {
+  const predecessors = receipt.verified.tombstonePredecessors;
+  const predecessorCount = predecessors.groups + predecessors.items + predecessors.attachments;
+  const observedCount = receipt.verified.vaults + receipt.verified.groups + receipt.verified.items + receipt.verified.attachments + receipt.verified.attachmentHeaders + receipt.verified.attachmentChunks + predecessorCount + receipt.verified.tombstones + receipt.verified.histories + receipt.verified.audits;
+  if (observedCount !== receipt.recordCount) {
+    context.addIssue({
+      code: "custom",
+      path: ["recordCount"],
+      message: "Restore verification counts do not match the backup record count"
+    });
+  }
+  if (receipt.verified.attachmentHeaders !== receipt.verified.attachments) {
+    context.addIssue({
+      code: "custom",
+      path: ["verified", "attachmentHeaders"],
+      message: "Every verified attachment must have one verified header"
+    });
+  }
+  if (receipt.verified.attachmentChunks < receipt.verified.attachments) {
+    context.addIssue({
+      code: "custom",
+      path: ["verified", "attachmentChunks"],
+      message: "Every verified attachment must have at least one verified chunk"
+    });
+  }
+  if (receipt.verified.tombstones < predecessorCount) {
+    context.addIssue({
+      code: "custom",
+      path: ["verified", "tombstones"],
+      message: "Verified tombstones cannot have more predecessors than tombstones"
+    });
+  }
+});
+var restoreProgressStatusSchema = external_exports.object({
+  protocolVersion: external_exports.literal(2),
+  restoreSessionId: sha256DigestSchema,
+  maximumBytes: external_exports.number().int().positive().max(MAX_SUPPORTED_BACKUP_BYTES),
+  maximumRecords: backupRecordCountSchema,
+  stagedBytes: external_exports.number().int().nonnegative().max(MAX_SUPPORTED_BACKUP_BYTES),
+  stagedRecords: backupSubcountSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+});
+var stagingRestoreStatusSchema = restoreProgressStatusSchema.extend({
+  state: external_exports.literal("staging"),
+  vaultId: vaultIdSchema.optional()
+}).strict();
+var sealedRestoreStatusSchema = restoreProgressStatusSchema.extend({
+  state: external_exports.literal("sealed"),
+  vaultId: vaultIdSchema,
+  summary: backupVerificationSchema,
+  sealedAt: timestampSchema
+}).strict();
+var publishedRestoreStatusSchema = restoreProgressStatusSchema.extend({
+  state: external_exports.literal("published"),
+  vaultId: vaultIdSchema,
+  summary: backupVerificationSchema,
+  sealedAt: timestampSchema,
+  publishedAt: timestampSchema
+}).strict();
+var committedRestoreStatusSchema = external_exports.object({
+  state: external_exports.literal("committed"),
+  protocolVersion: external_exports.literal(2),
+  restoreSessionId: sha256DigestSchema,
+  summary: backupVerificationSchema,
+  committedAt: timestampSchema
+}).strict();
+var abortedRestoreStatusSchema = external_exports.object({
+  state: external_exports.literal("aborted"),
+  protocolVersion: external_exports.literal(2),
+  restoreSessionId: sha256DigestSchema,
+  abortedAt: timestampSchema
+}).strict();
+var backupRestoreStatusSchema = external_exports.discriminatedUnion("state", [
+  stagingRestoreStatusSchema,
+  sealedRestoreStatusSchema,
+  publishedRestoreStatusSchema,
+  committedRestoreStatusSchema,
+  abortedRestoreStatusSchema
+]).superRefine((status, context) => {
+  if ("stagedBytes" in status && status.stagedBytes > status.maximumBytes) {
+    context.addIssue({
+      code: "custom",
+      path: ["stagedBytes"],
+      message: "Staged bytes exceed the restore session bound"
+    });
+  }
+  if ("stagedRecords" in status && status.stagedRecords > status.maximumRecords) {
+    context.addIssue({
+      code: "custom",
+      path: ["stagedRecords"],
+      message: "Staged records exceed the restore session bound"
+    });
+  }
+  if ("stagedRecords" in status) {
+    const hasStagedRecords = status.stagedRecords > 0;
+    const hasStagedBytes = status.stagedBytes > 0;
+    if (hasStagedRecords !== hasStagedBytes) {
+      context.addIssue({
+        code: "custom",
+        path: ["stagedRecords"],
+        message: "Restore staging record and byte progress must advance together"
+      });
+    }
+    if (status.state === "staging" && status.vaultId !== void 0 !== hasStagedRecords) {
+      context.addIssue({
+        code: "custom",
+        path: ["vaultId"],
+        message: "Restore staging binds a vault exactly when its prefix is nonempty"
+      });
+    }
+  }
+  if (status.state === "staging" || status.state === "aborted")
+    return;
+  if (status.restoreSessionId !== status.summary.restoreSessionId) {
+    context.addIssue({
+      code: "custom",
+      path: ["restoreSessionId"],
+      message: "Restore status and authenticated summary identify different sessions"
+    });
+  }
+  if (status.state === "committed")
+    return;
+  if (status.vaultId !== status.summary.header.vaultId) {
+    context.addIssue({
+      code: "custom",
+      path: ["vaultId"],
+      message: "Restore status and authenticated summary identify different vaults"
+    });
+  }
+  if (status.stagedRecords !== status.summary.recordCount || status.summary.recordCount > status.maximumRecords) {
+    context.addIssue({
+      code: "custom",
+      path: ["stagedRecords"],
+      message: "Frozen restore progress does not match the authenticated summary"
+    });
+  }
+});
+
+// ../../packages/schemas/dist/cli-contract.js
+var CLI_EXIT_CODES = Object.freeze({
+  ok: 0,
+  unclassifiedFailure: 1,
+  usageError: 2,
+  authenticationFailed: 10,
+  credentialMissing: 11,
+  authorizationDenied: 12,
+  grantInvalid: 13,
+  invalidConfiguration: 14,
+  datastoreFailure: 15,
+  securityIntegrityFailure: 16,
+  confirmationRequired: 17
+});
+var CLI_ERROR_CODES = [
+  "OK",
+  "UNCLASSIFIED_FAILURE",
+  "USAGE_ERROR",
+  "AUTHENTICATION_FAILED",
+  "CREDENTIAL_MISSING",
+  "AUTHORIZATION_DENIED",
+  "GRANT_INVALID",
+  "INVALID_CONFIGURATION",
+  "DATASTORE_FAILURE",
+  "SECURITY_INTEGRITY_FAILURE",
+  "CONFIRMATION_REQUIRED"
+];
+var cliErrorCodeSchema = external_exports.enum(CLI_ERROR_CODES);
+var CLI_ERROR_EXIT_CODES = Object.freeze({
+  OK: CLI_EXIT_CODES.ok,
+  UNCLASSIFIED_FAILURE: CLI_EXIT_CODES.unclassifiedFailure,
+  USAGE_ERROR: CLI_EXIT_CODES.usageError,
+  AUTHENTICATION_FAILED: CLI_EXIT_CODES.authenticationFailed,
+  CREDENTIAL_MISSING: CLI_EXIT_CODES.credentialMissing,
+  AUTHORIZATION_DENIED: CLI_EXIT_CODES.authorizationDenied,
+  GRANT_INVALID: CLI_EXIT_CODES.grantInvalid,
+  INVALID_CONFIGURATION: CLI_EXIT_CODES.invalidConfiguration,
+  DATASTORE_FAILURE: CLI_EXIT_CODES.datastoreFailure,
+  SECURITY_INTEGRITY_FAILURE: CLI_EXIT_CODES.securityIntegrityFailure,
+  CONFIRMATION_REQUIRED: CLI_EXIT_CODES.confirmationRequired
+});
+function exitCodeForCliError(code) {
+  return CLI_ERROR_EXIT_CODES[code];
+}
+var cliErrorEnvelopeSchema = external_exports.object({
+  error: external_exports.object({
+    code: cliErrorCodeSchema,
+    exitCode: external_exports.number().int().min(0).max(255),
+    message: external_exports.string().min(1).max(1024)
+  }).strict()
+}).strict();
+
+// ../../packages/schemas/dist/database-container.js
+var DATABASE_CONTAINER_FORMAT = "kavrix-encrypted-database";
+var FILE_DATABASE_CONTAINER_FORMAT = "kavrix-file-database-container";
+var CURRENT_DATABASE_CONTAINER_VERSION = 1;
+var MAX_DATABASE_RECOVERY_SLOTS = 32;
+var MAX_DATABASE_VAULTS = 1e3;
+var databaseRevisionSchema = external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).brand();
+var opaqueDatabaseEntityIdSchema = external_exports.union([
+  databaseIdSchema,
+  vaultIdSchema,
+  keySlotIdSchema
+]);
+var databaseAssociatedDataSchema = external_exports.object({
+  version: external_exports.literal(1),
+  databaseId: databaseIdSchema,
+  entityType: external_exports.enum([
+    "database-catalog",
+    "wrapped-database-root",
+    "wrapped-vault-root"
+  ]),
+  entityId: opaqueDatabaseEntityIdSchema,
+  purpose: external_exports.enum(["catalog", "database-root", "vault-root"]),
+  schemaVersion: supportedSchemaVersionSchema,
+  keyVersion: keyVersionSchema,
+  revision: databaseRevisionSchema,
+  vaultId: vaultIdSchema.optional(),
+  metadataDigest: sha256DigestSchema
+}).strict().superRefine((associatedData, context) => {
+  const invalidRelation = associatedData.entityType === "database-catalog" && (associatedData.purpose !== "catalog" || associatedData.entityId !== associatedData.databaseId || associatedData.vaultId !== void 0) || associatedData.entityType === "wrapped-database-root" && (associatedData.purpose !== "database-root" || !keySlotIdSchema.safeParse(associatedData.entityId).success || associatedData.vaultId !== void 0) || associatedData.entityType === "wrapped-vault-root" && (associatedData.purpose !== "vault-root" || !vaultIdSchema.safeParse(associatedData.entityId).success || associatedData.vaultId === void 0 || associatedData.entityId !== associatedData.vaultId);
+  if (invalidRelation) {
+    context.addIssue({
+      code: "custom",
+      message: "Database associated data has an invalid entity, purpose, or identity binding"
+    });
+  }
+});
+var databaseAeadEnvelopeSchema = external_exports.object({
+  version: envelopeVersionSchema,
+  algorithm: external_exports.literal("xchacha20-poly1305-ietf"),
+  nonce: base64UrlSchema,
+  ciphertext: base64UrlSchema,
+  authenticationTag: base64UrlSchema,
+  aad: databaseAssociatedDataSchema,
+  keyVersion: keyVersionSchema
+}).strict().superRefine((envelope, context) => {
+  if (envelope.nonce.length !== AEAD_NONCE_BASE64URL_CHARS) {
+    context.addIssue({
+      code: "custom",
+      message: "Nonce length does not match the authenticated-encryption algorithm",
+      path: ["nonce"]
+    });
+  }
+  if (envelope.authenticationTag.length !== AEAD_AUTHENTICATION_TAG_BASE64URL_CHARS) {
+    context.addIssue({
+      code: "custom",
+      message: "Authentication tag must encode 16 bytes",
+      path: ["authenticationTag"]
+    });
+  }
+  if (envelope.keyVersion !== envelope.aad.keyVersion) {
+    context.addIssue({
+      code: "custom",
+      message: "Envelope key version must be authenticated in associated data",
+      path: ["keyVersion"]
+    });
+  }
+});
+var databaseCatalogVaultSchema = external_exports.object({
+  id: vaultIdSchema,
+  label: external_exports.string().trim().min(1).max(256),
+  createdAt: timestampSchema
+}).strict();
+var databaseCatalogPayloadSchema = external_exports.object({
+  label: external_exports.string().trim().min(1).max(256),
+  vaults: external_exports.array(databaseCatalogVaultSchema).max(MAX_DATABASE_VAULTS)
+}).strict().superRefine((catalog, context) => {
+  const vaultIds = /* @__PURE__ */ new Set();
+  for (const [index, vault] of catalog.vaults.entries()) {
+    if (vaultIds.has(vault.id)) {
+      context.addIssue({
+        code: "custom",
+        path: ["vaults", index, "id"],
+        message: "Database catalog vault IDs must be unique"
+      });
+    }
+    vaultIds.add(vault.id);
+  }
+});
+var databasePortableKeyDerivationSchema = external_exports.object({
+  algorithm: external_exports.literal("hkdf-sha256"),
+  version: external_exports.literal(1),
+  salt: base64UrlSchema.length(43),
+  context: external_exports.literal("kavrix/database-root-wrap/v1"),
+  outputLength: external_exports.literal(32)
+}).strict();
+var databaseRecoveryKeyDerivationSchema = external_exports.object({
+  algorithm: external_exports.literal("hkdf-sha256"),
+  version: external_exports.literal(1),
+  salt: base64UrlSchema.length(43),
+  context: external_exports.literal("kavrix/database-recovery-wrap/v1"),
+  outputLength: external_exports.literal(32)
+}).strict();
+var databaseKeySlotBaseSchema = external_exports.object({
+  slotVersion: keySlotVersionSchema,
+  id: keySlotIdSchema,
+  state: external_exports.enum(["active", "revoked"]),
+  keyVersion: keyVersionSchema,
+  wrappedDatabaseRoot: databaseAeadEnvelopeSchema,
+  createdAt: timestampSchema,
+  revokedAt: timestampSchema.optional()
+});
+var databasePortableKeySlotSchema = databaseKeySlotBaseSchema.extend({
+  type: external_exports.literal("portable-key"),
+  state: external_exports.literal("active"),
+  derivation: databasePortableKeyDerivationSchema
+}).strict().superRefine((slot, context) => {
+  if (slot.revokedAt !== void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["revokedAt"],
+      message: "Active database portable-key slots cannot have a revocation timestamp"
+    });
+  }
+  validateDatabaseRootSlotBinding(slot, context);
+});
+var databaseRecoverySlotSchema = databaseKeySlotBaseSchema.extend({
+  type: external_exports.literal("recovery-key"),
+  derivation: databaseRecoveryKeyDerivationSchema
+}).strict().superRefine((slot, context) => {
+  if (slot.state === "revoked" && slot.revokedAt === void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["revokedAt"],
+      message: "Revoked database recovery slots require a timestamp"
+    });
+  }
+  if (slot.state === "active" && slot.revokedAt !== void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["revokedAt"],
+      message: "Active database recovery slots cannot have a revocation timestamp"
+    });
+  }
+  validateDatabaseRootSlotBinding(slot, context);
+});
+var encryptedDatabaseDocumentSchema = external_exports.object({
+  format: external_exports.literal(DATABASE_CONTAINER_FORMAT),
+  version: external_exports.literal(CURRENT_DATABASE_CONTAINER_VERSION),
+  id: databaseIdSchema,
+  schemaVersion: supportedSchemaVersionSchema,
+  cryptographicVersion: supportedCryptographicVersionSchema,
+  currentKeyVersion: keyVersionSchema,
+  keySlot: databasePortableKeySlotSchema,
+  recoverySlots: external_exports.array(databaseRecoverySlotSchema).max(MAX_DATABASE_RECOVERY_SLOTS),
+  revision: databaseRevisionSchema,
+  encryptedCatalog: databaseAeadEnvelopeSchema,
+  catalogMetadataDigest: sha256DigestSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+}).strict().superRefine((database, context) => {
+  if (database.keySlot.keyVersion !== database.currentKeyVersion) {
+    context.addIssue({
+      code: "custom",
+      path: ["keySlot", "keyVersion"],
+      message: "Database portable-key slot version must match the current key version"
+    });
+  }
+  if (database.keySlot.wrappedDatabaseRoot.aad.databaseId !== database.id) {
+    context.addIssue({
+      code: "custom",
+      path: ["keySlot", "wrappedDatabaseRoot", "aad", "databaseId"],
+      message: "Database portable-key slot belongs to another database"
+    });
+  }
+  const keySlotIds = /* @__PURE__ */ new Set([database.keySlot.id]);
+  for (const [index, slot] of database.recoverySlots.entries()) {
+    if (keySlotIds.has(slot.id)) {
+      context.addIssue({
+        code: "custom",
+        path: ["recoverySlots", index, "id"],
+        message: "Database key slot IDs must be unique"
+      });
+    }
+    keySlotIds.add(slot.id);
+    if (slot.keyVersion !== database.currentKeyVersion) {
+      context.addIssue({
+        code: "custom",
+        path: ["recoverySlots", index, "keyVersion"],
+        message: "Database recovery slot version must match the current key version"
+      });
+    }
+    if (slot.wrappedDatabaseRoot.aad.databaseId !== database.id) {
+      context.addIssue({
+        code: "custom",
+        path: ["recoverySlots", index, "wrappedDatabaseRoot", "aad", "databaseId"],
+        message: "Database recovery slot belongs to another database"
+      });
+    }
+  }
+  const catalog = database.encryptedCatalog;
+  if (catalog.aad.databaseId !== database.id || catalog.aad.schemaVersion !== database.schemaVersion || catalog.aad.keyVersion !== database.currentKeyVersion || catalog.aad.revision !== database.revision || catalog.aad.metadataDigest !== database.catalogMetadataDigest) {
+    context.addIssue({
+      code: "custom",
+      path: ["encryptedCatalog", "aad"],
+      message: "Encrypted database catalog has invalid associated data"
+    });
+  }
+});
+var databaseVaultDocumentSchema = external_exports.object({
+  databaseId: databaseIdSchema,
+  id: vaultIdSchema,
+  schemaVersion: supportedSchemaVersionSchema,
+  cryptographicVersion: supportedCryptographicVersionSchema,
+  currentKeyVersion: keyVersionSchema,
+  databaseRevision: databaseRevisionSchema,
+  revision: vaultRevisionSchema,
+  wrappedVaultRoot: databaseAeadEnvelopeSchema,
+  encryptedPayload: aeadEnvelopeSchema,
+  payloadMetadataDigest: sha256DigestSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+}).strict().superRefine((vault, context) => {
+  const wrappedRoot = vault.wrappedVaultRoot;
+  if (wrappedRoot.aad.databaseId !== vault.databaseId || wrappedRoot.aad.vaultId !== vault.id || wrappedRoot.aad.schemaVersion !== vault.schemaVersion || wrappedRoot.aad.keyVersion !== vault.currentKeyVersion || wrappedRoot.aad.revision !== vault.databaseRevision) {
+    context.addIssue({
+      code: "custom",
+      path: ["wrappedVaultRoot", "aad"],
+      message: "Wrapped vault root has invalid associated data"
+    });
+  }
+  const payload = vault.encryptedPayload;
+  if (payload.aad.vaultId !== vault.id || !isVaultPreferencesPayloadDomain(payload.aad) || payload.aad.entityId !== vault.id || payload.aad.schemaVersion !== vault.schemaVersion || payload.aad.keyVersion !== vault.currentKeyVersion || payload.aad.revision !== vault.revision || payload.aad.metadataDigest !== vault.payloadMetadataDigest) {
+    context.addIssue({
+      code: "custom",
+      path: ["encryptedPayload", "aad"],
+      message: "Encrypted vault payload has invalid associated data"
+    });
+  }
+});
+function isVaultPreferencesPayloadDomain(value) {
+  return value.entityType === "vault-preferences" && value.purpose === "vault-preferences";
+}
+var fileDatabaseContainerSchema = external_exports.object({
+  format: external_exports.literal(FILE_DATABASE_CONTAINER_FORMAT),
+  version: external_exports.literal(CURRENT_DATABASE_CONTAINER_VERSION),
+  database: encryptedDatabaseDocumentSchema,
+  vaults: external_exports.record(vaultIdSchema, databaseVaultDocumentSchema)
+}).strict().superRefine((container, context) => {
+  const entries = Object.entries(container.vaults);
+  if (entries.length > MAX_DATABASE_VAULTS) {
+    context.addIssue({
+      code: "custom",
+      path: ["vaults"],
+      message: "Database container contains too many vaults"
+    });
+  }
+  for (const [vaultId, vault] of entries) {
+    if (vaultId !== vault.id) {
+      context.addIssue({
+        code: "custom",
+        path: ["vaults", vaultId],
+        message: "Database container vault map keys must match vault IDs"
+      });
+    }
+    if (vault.databaseId !== container.database.id) {
+      context.addIssue({
+        code: "custom",
+        path: ["vaults", vaultId, "databaseId"],
+        message: "Database container vault belongs to another database"
+      });
+    }
+  }
+});
+function validateDatabaseRootSlotBinding(slot, context) {
+  const envelope = slot.wrappedDatabaseRoot;
+  if (envelope.aad.entityId !== slot.id) {
+    context.addIssue({
+      code: "custom",
+      path: ["wrappedDatabaseRoot", "aad", "entityId"],
+      message: "Database root slot envelope is bound to a different slot"
+    });
+  }
+  if (envelope.keyVersion !== slot.keyVersion) {
+    context.addIssue({
+      code: "custom",
+      path: ["wrappedDatabaseRoot", "keyVersion"],
+      message: "Database root slot envelope version must match its slot"
+    });
+  }
+}
+
+// ../../packages/schemas/dist/keychain.js
+var deviceUnlockSecretSchema = external_exports.instanceof(Uint8Array).refine((value) => value.byteLength === 32, {
+  error: "Device unlock secrets must contain exactly 32 bytes"
+}).brand();
+var keychainLocatorSchema = external_exports.object({
+  version: external_exports.literal(1),
+  vaultId: vaultIdSchema,
+  deviceId: deviceIdSchema,
+  keySlotId: keySlotIdSchema
+}).strict();
+var sessionCredentialSecretSchema = external_exports.instanceof(Uint8Array).refine((value) => value.byteLength === 32, {
+  error: "Session credential secrets must contain exactly 32 bytes"
+}).brand();
+var sessionCredentialLocatorSchema = external_exports.object({
+  version: external_exports.literal(1),
+  vaultId: vaultIdSchema,
+  deviceId: deviceIdSchema,
+  purpose: external_exports.literal("api-session")
+}).strict();
+
+// ../../packages/schemas/dist/policy.js
+var MAX_CREDENTIAL_REFERENCE_CHARS = 256;
+var MAX_COMMANDS_PER_ENTRY = 64;
+var MAX_STORED_POLICIES = 128;
+var MAX_STORED_GRANTS = 128;
+var MAX_RUNTIME_AUDIT_EVENTS = 512;
+var MAX_PROJECT_POLICIES = 128;
+var MAX_PROJECT_ENVIRONMENTS = 32;
+var MAX_SECRETS_PER_ENVIRONMENT = 64;
+var MAX_PROJECT_AGENTS = 32;
+var MAX_PERMISSIONS_PER_AGENT = 64;
+var MAX_CONFIRMATION_TOKENS = 16;
+var MAX_ARGV_PREVIEW_ENTRIES = 8;
+var MAX_ARGV_PREVIEW_CHARS = 64;
+var MAX_POLICY_DURATION_MS = 30 * 24 * 60 * 60 * 1e3;
+var MAX_AUTHORIZATION_STATE_BYTES = 512 * 1024;
+var RESERVED_CREDENTIAL_REFERENCES = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+var credentialReferenceSchema = external_exports.string().min(1).max(MAX_CREDENTIAL_REFERENCE_CHARS).refine((value) => !/[\u0000-\u001f\u007f]/u.test(value), {
+  message: "Credential references must not contain control characters"
+}).refine((value) => value.trim() === value, {
+  message: "Credential references must not start or end with whitespace"
+}).refine((value) => !RESERVED_CREDENTIAL_REFERENCES.has(value), {
+  message: "Credential reference is reserved"
+});
+var environmentNameSchema = external_exports.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u, "Invalid environment name");
+var ENVIRONMENT_VARIABLE_NAME_PATTERN_SOURCE = "^[A-Za-z_][A-Za-z0-9_]{0,127}$";
+var environmentVariableNameSchema = external_exports.string().regex(new RegExp(ENVIRONMENT_VARIABLE_NAME_PATTERN_SOURCE), "Invalid environment variable name");
+var commandNameSchema = external_exports.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._+-]*$/u, "Command names must be bare executable names");
+var commandTokenSchema = external_exports.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._=+-]*$/u, "Invalid command token");
+var opaquePattern = new RegExp(OPAQUE_ID_PATTERN_SOURCE);
+var opaqueIdentifierSchema = external_exports.string().min(1).max(128).regex(opaquePattern, "Must be an opaque identifier");
+var sha256HexDigestSchema = external_exports.string().regex(/^[0-9a-f]{64}$/u, "Must be a lowercase hex SHA-256 digest");
+var DURATION_PATTERN_SOURCE = "^([1-9][0-9]{0,6})([smhd])$";
+var durationPattern = new RegExp(DURATION_PATTERN_SOURCE);
+var durationSchema = external_exports.string().regex(durationPattern, "Invalid duration");
+function parseDurationToMs(value) {
+  if (!durationPattern.test(value))
+    return void 0;
+  const match = durationPattern.exec(value);
+  const amountText = match?.[1];
+  const unit = match?.[2];
+  if (amountText === void 0 || unit === void 0)
+    return void 0;
+  const amount = Number(amountText);
+  if (!Number.isSafeInteger(amount) || amount <= 0)
+    return void 0;
+  const multiplier = UNIT_MULTIPLIERS[unit];
+  if (multiplier === void 0)
+    return void 0;
+  const totalMs = amount * multiplier;
+  return totalMs <= MAX_POLICY_DURATION_MS ? totalMs : void 0;
+}
+var UNIT_MULTIPLIERS = Object.freeze({
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+});
+var confirmationRequirementSchema = external_exports.union([
+  external_exports.boolean(),
+  external_exports.array(commandTokenSchema).min(1).max(MAX_CONFIRMATION_TOKENS)
+]);
+var positiveMaxUsesSchema = external_exports.number().int().min(1).max(1e6);
+var workingDirectorySchema = external_exports.string().min(1).max(1024).refine((value) => !/[\u0000-\u001f\u007f]/u.test(value), {
+  message: "Working directories must not contain control characters"
+});
+var permissionEntrySchema = external_exports.object({
+  secret: credentialReferenceSchema.optional(),
+  commands: external_exports.array(commandNameSchema).min(1).max(MAX_COMMANDS_PER_ENTRY).optional(),
+  hashes: external_exports.record(commandNameSchema, sha256HexDigestSchema).optional(),
+  env: environmentVariableNameSchema.optional(),
+  reveal: external_exports.boolean().optional(),
+  ttl: durationSchema.optional(),
+  maxUses: positiveMaxUsesSchema.optional(),
+  requireConfirmation: confirmationRequirementSchema.optional(),
+  /** Restricts use to invocations whose working directory is inside this directory subtree. */
+  workingDirectory: workingDirectorySchema.optional(),
+  deny: external_exports.boolean().optional()
+}).strict().superRefine((entry, context) => {
+  const deny = entry.deny === true;
+  if (!deny) {
+    if (entry.secret === void 0) {
+      context.addIssue({
+        code: "custom",
+        message: "A permission entry requires a secret reference unless it denies",
+        path: ["secret"]
+      });
+    }
+    if (entry.commands === void 0) {
+      context.addIssue({
+        code: "custom",
+        message: "A permission entry requires at least one allowed command",
+        path: ["commands"]
+      });
+    }
+  } else {
+    for (const field of [
+      "commands",
+      "hashes",
+      "ttl",
+      "maxUses",
+      "requireConfirmation",
+      "workingDirectory"
+    ]) {
+      if (entry[field] !== void 0) {
+        context.addIssue({
+          code: "custom",
+          message: "A deny entry must not carry allowlist fields",
+          path: [field]
+        });
+      }
+    }
+  }
+  if (entry.hashes === void 0 || entry.commands === void 0)
+    return;
+  const commands = new Set(entry.commands);
+  for (const pinned of Object.keys(entry.hashes)) {
+    if (!commands.has(pinned)) {
+      context.addIssue({
+        code: "custom",
+        message: "Executable pins must reference listed commands",
+        path: ["hashes"]
+      });
+      return;
+    }
+  }
+});
+function normalizePermissionEntryAliases(value) {
+  if (!isPlainObject(value))
+    return value;
+  let renamed = false;
+  const output = {};
+  for (const [key, entryValue] of Object.entries(value)) {
+    if (key === "require_confirmation") {
+      output["requireConfirmation"] ??= entryValue;
+      renamed = true;
+      continue;
+    }
+    if (key === "max_uses") {
+      output["maxUses"] ??= entryValue;
+      renamed = true;
+      continue;
+    }
+    output[key] = entryValue;
+  }
+  return renamed ? output : value;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeProjectConfigAliases(input) {
+  if (!isPlainObject(input))
+    return input;
+  let document = input;
+  let changed = false;
+  const policies = normalizedMap(document["policies"]);
+  if (policies.changed) {
+    document = { ...document, policies: policies.map };
+    changed = true;
+  }
+  if (isPlainObject(document["agents"])) {
+    const agents = {};
+    let agentsChanged = false;
+    for (const [agentId, agent] of Object.entries(document["agents"])) {
+      if (!isPlainObject(agent)) {
+        agents[agentId] = agent;
+        continue;
+      }
+      const permissions = normalizedMap(agent["permissions"]);
+      if (permissions.changed) {
+        agents[agentId] = { ...agent, ["permissions"]: permissions.map };
+        agentsChanged = true;
+        continue;
+      }
+      agents[agentId] = agent;
+    }
+    if (agentsChanged) {
+      document = { ...document, agents };
+      changed = true;
+    }
+  }
+  if (isPlainObject(document["environments"])) {
+    const environments = {};
+    let environmentsChanged = false;
+    for (const [environmentId, environment] of Object.entries(document["environments"])) {
+      if (!isPlainObject(environment)) {
+        environments[environmentId] = environment;
+        continue;
+      }
+      const policies2 = normalizedMap(environment["policies"]);
+      if (policies2.changed) {
+        environments[environmentId] = { ...environment, ["policies"]: policies2.map };
+        environmentsChanged = true;
+        continue;
+      }
+      environments[environmentId] = environment;
+    }
+    if (environmentsChanged) {
+      document = { ...document, environments };
+      changed = true;
+    }
+  }
+  return changed ? document : input;
+}
+function normalizedMap(mapValue) {
+  if (!isPlainObject(mapValue))
+    return { changed: false, map: mapValue };
+  const next = {};
+  let changed = false;
+  for (const [key, entry] of Object.entries(mapValue)) {
+    const normalized = normalizePermissionEntryAliases(entry);
+    if (normalized !== entry)
+      changed = true;
+    next[key] = normalized;
+  }
+  return changed ? { changed: true, map: next } : { changed: false, map: mapValue };
+}
+var projectEnvironmentSchema = external_exports.object({
+  secrets: external_exports.record(environmentVariableNameSchema, credentialReferenceSchema).optional(),
+  policies: external_exports.record(opaqueIdentifierSchema, permissionEntrySchema).optional()
+}).strict().superRefine((environment, context) => {
+  if ((environment.secrets === void 0 ? 0 : Object.keys(environment.secrets).length) > MAX_SECRETS_PER_ENVIRONMENT) {
+    context.addIssue({
+      code: "custom",
+      message: "An environment defines too many secret mappings",
+      path: ["secrets"]
+    });
+  }
+  if ((environment.policies === void 0 ? 0 : Object.keys(environment.policies).length) > MAX_PERMISSIONS_PER_AGENT) {
+    context.addIssue({
+      code: "custom",
+      message: "An environment defines too many policies",
+      path: ["policies"]
+    });
+  }
+});
+var projectAgentSchema = external_exports.object({
+  permissions: external_exports.record(opaqueIdentifierSchema, permissionEntrySchema)
+}).strict().superRefine((agent, context) => {
+  if (Object.keys(agent.permissions).length < 1) {
+    context.addIssue({
+      code: "custom",
+      message: "An agent requires at least one permission entry",
+      path: ["permissions"]
+    });
+  }
+  if (Object.keys(agent.permissions).length > MAX_PERMISSIONS_PER_AGENT) {
+    context.addIssue({
+      code: "custom",
+      message: "An agent defines too many permission entries",
+      path: ["permissions"]
+    });
+  }
+});
+var projectConfigDocumentSchema = external_exports.object({
+  version: external_exports.literal(1),
+  project: slugSchema.optional(),
+  environments: external_exports.record(environmentNameSchema, projectEnvironmentSchema).optional(),
+  policies: external_exports.record(opaqueIdentifierSchema, permissionEntrySchema).optional(),
+  agents: external_exports.record(opaqueIdentifierSchema, projectAgentSchema).optional()
+}).strict().superRefine((document, context) => {
+  if ((document.environments === void 0 ? 0 : Object.keys(document.environments).length) > MAX_PROJECT_ENVIRONMENTS) {
+    context.addIssue({
+      code: "custom",
+      message: "The project file defines too many environments",
+      path: ["environments"]
+    });
+  }
+  if ((document.agents === void 0 ? 0 : Object.keys(document.agents).length) > MAX_PROJECT_AGENTS) {
+    context.addIssue({
+      code: "custom",
+      message: "The project file defines too many agents",
+      path: ["agents"]
+    });
+  }
+  const policyCount = (document.policies === void 0 ? 0 : Object.keys(document.policies).length) + Object.values(document.environments ?? {}).reduce((total, environment) => total + (environment.policies === void 0 ? 0 : Object.keys(environment.policies).length), 0);
+  if (policyCount > MAX_PROJECT_POLICIES) {
+    context.addIssue({
+      code: "custom",
+      message: "The project file defines too many policies",
+      path: ["policies"]
+    });
+  }
+});
+var grantActorSchema = external_exports.enum(["user", "agent"]);
+var grantRecordSchema = external_exports.object({
+  grantId: grantIdSchema,
+  secret: credentialReferenceSchema,
+  actor: grantActorSchema,
+  commands: external_exports.array(commandNameSchema).min(1).max(MAX_COMMANDS_PER_ENTRY),
+  hashes: external_exports.record(commandNameSchema, sha256HexDigestSchema).optional(),
+  env: environmentVariableNameSchema.optional(),
+  createdByPolicyId: opaqueIdentifierSchema.optional(),
+  agentPermissionKey: opaqueIdentifierSchema.optional(),
+  createdAt: timestampSchema,
+  expiresAt: timestampSchema.optional(),
+  maxUses: positiveMaxUsesSchema.optional(),
+  usedCount: external_exports.number().int().nonnegative(),
+  lastUsedAt: timestampSchema.optional(),
+  revokedAt: timestampSchema.optional()
+}).strict().superRefine((grant, context) => {
+  if (grant.maxUses !== void 0 && grant.usedCount > grant.maxUses) {
+    context.addIssue({
+      code: "custom",
+      message: "A grant cannot record more uses than its maximum",
+      path: ["usedCount"]
+    });
+  }
+  if (grant.expiresAt !== void 0 && grant.expiresAt <= grant.createdAt) {
+    context.addIssue({
+      code: "custom",
+      message: "A grant must expire after it was created",
+      path: ["expiresAt"]
+    });
+  }
+  if (grant.revokedAt !== void 0 && grant.revokedAt < grant.createdAt) {
+    context.addIssue({
+      code: "custom",
+      message: "A grant cannot be revoked before it was created",
+      path: ["revokedAt"]
+    });
+  }
+  if (grant.hashes === void 0)
+    return;
+  const commands = new Set(grant.commands);
+  for (const pinned of Object.keys(grant.hashes)) {
+    if (!commands.has(pinned)) {
+      context.addIssue({
+        code: "custom",
+        message: "Executable pins must reference granted commands",
+        path: ["hashes"]
+      });
+      return;
+    }
+  }
+});
+var storedPolicyRecordSchema = external_exports.object({
+  definition: permissionEntrySchema,
+  createdAt: timestampSchema
+}).strict();
+var ALLOW_DECISION_REASONS = Object.freeze([
+  "no-applicable-policy",
+  "policy-allowed",
+  "grant-allowed"
+]);
+var CONFIRM_DECISION_REASONS = Object.freeze([
+  "confirmation-required"
+]);
+var DENY_DECISION_REASONS = Object.freeze([
+  "policy-denied",
+  "command-not-allowed",
+  "hash-mismatch",
+  "expired",
+  "exhausted",
+  "revoked",
+  "reveal-forbidden-by-policy",
+  "confirmation-declined",
+  "confirmation-unavailable",
+  "executable-unresolved",
+  "executable-refused",
+  "clock-invalid",
+  "state-corrupt",
+  "no-injection-mapping",
+  "working-directory-mismatch",
+  "invalid-request"
+]);
+var authorizationReasonSchema = external_exports.enum([
+  ...ALLOW_DECISION_REASONS,
+  ...CONFIRM_DECISION_REASONS,
+  ...DENY_DECISION_REASONS
+]);
+var authorizationDecisionSchema = external_exports.discriminatedUnion("outcome", [
+  external_exports.object({
+    outcome: external_exports.literal("allow"),
+    reason: external_exports.enum(ALLOW_DECISION_REASONS),
+    policyId: opaqueIdentifierSchema.optional(),
+    grantId: opaqueIdentifierSchema.optional(),
+    secret: credentialReferenceSchema.optional()
+  }).strict(),
+  external_exports.object({
+    outcome: external_exports.literal("confirm"),
+    reason: external_exports.enum(CONFIRM_DECISION_REASONS),
+    policyId: opaqueIdentifierSchema.optional(),
+    secret: credentialReferenceSchema.optional()
+  }).strict(),
+  external_exports.object({
+    outcome: external_exports.literal("deny"),
+    reason: external_exports.enum(DENY_DECISION_REASONS),
+    policyId: opaqueIdentifierSchema.optional(),
+    grantId: opaqueIdentifierSchema.optional(),
+    secret: credentialReferenceSchema.optional()
+  }).strict()
+]);
+var runtimeAuditActorSchema = external_exports.enum(["user", "agent"]);
+var runtimeAuditActionSchema = external_exports.enum([
+  "unlock",
+  "policy-created",
+  "policy-updated",
+  "policy-removed",
+  "grant-created",
+  "grant-revoked",
+  "grant-expired",
+  "grant-exhausted",
+  "authorization-allowed",
+  "authorization-denied",
+  "reveal-attempted",
+  "reveal-denied",
+  "confirmation-requested",
+  "confirmation-granted",
+  "confirmation-declined",
+  "execution-completed"
+]);
+var sanitizedPreviewTextSchema = external_exports.string().min(1).max(MAX_ARGV_PREVIEW_CHARS).refine((value) => !/[\u0000-\u001f\u007f]/u.test(value), {
+  message: "Audit preview text must not contain control characters"
+});
+var runtimeAuditEventSchema = external_exports.object({
+  seq: external_exports.number().int().positive(),
+  occurredAt: timestampSchema,
+  actor: runtimeAuditActorSchema,
+  action: runtimeAuditActionSchema,
+  policyId: opaqueIdentifierSchema.optional(),
+  grantId: opaqueIdentifierSchema.optional(),
+  permissionKey: opaqueIdentifierSchema.optional(),
+  secret: credentialReferenceSchema.optional(),
+  command: commandNameSchema.optional(),
+  argvPreview: external_exports.array(sanitizedPreviewTextSchema).max(MAX_ARGV_PREVIEW_ENTRIES).optional(),
+  exitCode: external_exports.number().int().min(-2147483648).max(2147483647).optional(),
+  reason: authorizationReasonSchema.optional()
+}).strict();
+var authorizationScopeKindSchema = external_exports.enum(["database", "vault"]);
+var authorizationStateDomainSchema = external_exports.literal("kavrix/authorization-state/v1");
+var authorizationEnvelopeContextSchema = external_exports.object({
+  domain: authorizationStateDomainSchema,
+  scopeKind: authorizationScopeKindSchema,
+  scopeId: opaqueIdentifierSchema,
+  sequence: external_exports.number().int().nonnegative()
+}).strict();
+var authorizationStateDocumentSchema = external_exports.object({
+  version: external_exports.literal(1),
+  policies: external_exports.record(opaqueIdentifierSchema, storedPolicyRecordSchema),
+  grants: external_exports.record(grantIdSchema, grantRecordSchema),
+  audit: external_exports.array(runtimeAuditEventSchema).max(MAX_RUNTIME_AUDIT_EVENTS)
+}).strict().superRefine((state, context) => {
+  if (Object.keys(state.policies).length > MAX_STORED_POLICIES) {
+    context.addIssue({
+      code: "custom",
+      message: "The authorization state holds too many policies",
+      path: ["policies"]
+    });
+  }
+  if (Object.keys(state.grants).length > MAX_STORED_GRANTS) {
+    context.addIssue({
+      code: "custom",
+      message: "The authorization state holds too many grants",
+      path: ["grants"]
+    });
+  }
+});
+var authorizationStateFormatSchema = external_exports.literal("kavrix-authorization-state");
+var authorizationStateEnvelopeSchema = external_exports.object({
+  format: authorizationStateFormatSchema,
+  version: external_exports.literal(1),
+  scopeKind: authorizationScopeKindSchema,
+  scopeId: opaqueIdentifierSchema,
+  sequence: external_exports.number().int().nonnegative(),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  nonce: base64UrlSchema.length(AEAD_NONCE_BASE64URL_CHARS),
+  ciphertext: base64UrlSchema,
+  authenticationTag: base64UrlSchema.length(AEAD_AUTHENTICATION_TAG_BASE64URL_CHARS)
+}).strict();
+var BASE64_CHUNK_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u;
+var MAX_BROKER_ARGV_ENTRIES = 128;
+var MAX_BROKER_ARG_CHARS = 8192;
+var MAX_BROKER_FRAME_BYTES = 2 * 1024 * 1024;
+var agentBrokerRequestSchema = external_exports.object({
+  v: external_exports.literal(1),
+  token: external_exports.string().min(32).max(256),
+  op: external_exports.literal("exec"),
+  permission: opaqueIdentifierSchema,
+  argv: external_exports.array(external_exports.string().min(1).max(MAX_BROKER_ARG_CHARS)).min(1).max(MAX_BROKER_ARGV_ENTRIES)
+}).strict();
+var agentBrokerDecisionFrameSchema = external_exports.object({
+  v: external_exports.literal(1),
+  event: external_exports.literal("decision"),
+  outcome: external_exports.enum(["allow", "deny"]),
+  reason: authorizationReasonSchema
+}).strict();
+var agentBrokerOutputFrameSchema = external_exports.object({
+  v: external_exports.literal(1),
+  event: external_exports.enum(["stdout", "stderr"]),
+  data: external_exports.string().regex(BASE64_CHUNK_PATTERN, "Frames carry standard base64")
+}).strict();
+var agentBrokerExitFrameSchema = external_exports.object({
+  v: external_exports.literal(1),
+  event: external_exports.literal("exit"),
+  exitCode: external_exports.number().int().min(-2147483648).max(2147483647).nullable(),
+  signal: external_exports.string().min(1).max(32).nullable()
+}).strict();
+var agentBrokerServerFrameSchema = external_exports.discriminatedUnion("event", [
+  agentBrokerDecisionFrameSchema,
+  agentBrokerOutputFrameSchema,
+  agentBrokerExitFrameSchema
+]);
+var agentBrokerClientFrameSchema = external_exports.discriminatedUnion("event", [
+  external_exports.object({
+    v: external_exports.literal(1),
+    event: external_exports.literal("stdin"),
+    data: external_exports.string().regex(BASE64_CHUNK_PATTERN)
+  }).strict(),
+  external_exports.object({ v: external_exports.literal(1), event: external_exports.literal("close-stdin") }).strict()
+]);
+
+// ../../packages/schemas/dist/rotation.js
+var portableKeyRotationStateSchema = external_exports.enum([
+  "prepared",
+  "pending-published",
+  "active-published",
+  "completed"
+]);
+var rotationOperationIdSchema = external_exports.string().min(16).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._~-]*$/u);
+var portableKeyRotationCheckpointPayloadSchema = external_exports.object({
+  version: external_exports.literal(1),
+  vaultId: vaultIdSchema,
+  operationId: rotationOperationIdSchema,
+  sourceSlotId: keySlotIdSchema,
+  replacementSlotId: keySlotIdSchema,
+  sourceRevision: vaultRevisionSchema,
+  remoteRevision: vaultRevisionSchema,
+  sourceSlotDigest: sha256DigestSchema,
+  replacementSlotDigest: sha256DigestSchema,
+  transcriptDigest: sha256DigestSchema,
+  state: portableKeyRotationStateSchema
+}).strict().superRefine((payload, context) => {
+  if (payload.sourceSlotId === payload.replacementSlotId) {
+    context.addIssue({
+      code: "custom",
+      path: ["replacementSlotId"],
+      message: "A rotation must use distinct source and replacement slots"
+    });
+  }
+  const offset = {
+    prepared: 0,
+    "pending-published": 1,
+    "active-published": 2,
+    completed: 3
+  }[payload.state];
+  if (payload.sourceRevision + offset !== payload.remoteRevision) {
+    context.addIssue({
+      code: "custom",
+      path: ["remoteRevision"],
+      message: "The checkpoint revision does not match its lifecycle state"
+    });
+  }
+});
+var portableKeyRotationCheckpointSchema = external_exports.object({
+  payload: portableKeyRotationCheckpointPayloadSchema,
+  authenticationTag: sha256DigestSchema
+}).strict();
+var portableKeyRotationSourceKindSchema = external_exports.enum([
+  "generated-file",
+  "imported-file"
+]);
+var portableSlotSchema = keySlotSchema.refine((slot) => slot.type === "portable-key", {
+  error: "Portable-key rotation requires portable-key slots"
+});
+var portableKeyRotationJournalRecordSchema = external_exports.object({
+  version: external_exports.literal(1),
+  kind: external_exports.literal("portable-key-rotation"),
+  operationId: rotationOperationIdSchema,
+  vaultId: vaultIdSchema,
+  deviceId: deviceIdSchema,
+  state: portableKeyRotationStateSchema,
+  sourceKind: portableKeyRotationSourceKindSchema,
+  sourceSlot: portableSlotSchema,
+  replacementSlot: portableSlotSchema,
+  sourceRevision: vaultRevisionSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  checkpoint: portableKeyRotationCheckpointSchema
+}).strict().superRefine((record, context) => {
+  const expectedReplacementState = record.state === "prepared" || record.state === "pending-published" ? "pending" : "active";
+  if (record.sourceSlot.state !== "active" || record.replacementSlot.state !== expectedReplacementState || record.sourceSlot.id === record.replacementSlot.id || record.sourceSlot.keyVersion !== record.replacementSlot.keyVersion || record.sourceRevision !== record.checkpoint.payload.sourceRevision || record.checkpoint.payload.vaultId !== record.vaultId || record.checkpoint.payload.operationId !== record.operationId || record.checkpoint.payload.sourceSlotId !== record.sourceSlot.id || record.checkpoint.payload.replacementSlotId !== record.replacementSlot.id || record.checkpoint.payload.state !== record.state) {
+    context.addIssue({
+      code: "custom",
+      path: ["checkpoint"],
+      message: "The rotation journal record and checkpoint must agree"
+    });
+  }
+});
+var PORTABLE_KEY_ROTATION_JOURNAL_MAX_SERIALIZED_BYTES = 64 * 1024;
+
+// ../../packages/schemas/dist/session-lifetime.js
+var MIN_SESSION_TIMEOUT_MS = 1e3;
+var MAX_SESSION_TIMEOUT_MS = 864e5;
+var DEFAULT_INVOCATION_TIMEOUT_MS = 9e5;
+var DEFAULT_IDLE_TIMEOUT_MS = 12e4;
+var DEFAULT_REAUTHENTICATION_WINDOW_MS = 12e4;
+var sessionExpiryReasonSchema = external_exports.enum([
+  /** The whole invocation reached its wall-clock limit. */
+  "invocation-timeout",
+  /** No activity was recorded within the inactivity limit. */
+  "idle-timeout",
+  /** The operator interrupted the invocation (SIGINT). */
+  "interrupted",
+  /** The supervisor asked the process to stop (SIGTERM). */
+  "terminated",
+  /** The controlling terminal went away (SIGHUP). */
+  "hangup",
+  /** The monotonic clock moved backward, so deadlines are unenforceable. */
+  "clock-regression"
+]);
+var sessionLifetimePolicySchema = external_exports.object({
+  invocationTimeoutMs: external_exports.number().int().min(MIN_SESSION_TIMEOUT_MS).max(MAX_SESSION_TIMEOUT_MS),
+  idleTimeoutMs: external_exports.number().int().min(MIN_SESSION_TIMEOUT_MS).max(MAX_SESSION_TIMEOUT_MS),
+  reauthenticationWindowMs: external_exports.number().int().min(MIN_SESSION_TIMEOUT_MS).max(MAX_SESSION_TIMEOUT_MS)
+}).strict().superRefine((policy, context) => {
+  if (policy.idleTimeoutMs > policy.invocationTimeoutMs) {
+    context.addIssue({
+      code: "custom",
+      message: "An inactivity limit cannot exceed the invocation limit",
+      path: ["idleTimeoutMs"]
+    });
+  }
+  if (policy.reauthenticationWindowMs > policy.invocationTimeoutMs) {
+    context.addIssue({
+      code: "custom",
+      message: "A reauthentication window cannot exceed the invocation limit",
+      path: ["reauthenticationWindowMs"]
+    });
+  }
+});
+var DEFAULT_SESSION_LIFETIME_POLICY = Object.freeze({
+  invocationTimeoutMs: DEFAULT_INVOCATION_TIMEOUT_MS,
+  idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
+  reauthenticationWindowMs: DEFAULT_REAUTHENTICATION_WINDOW_MS
+});
+
+// ../../packages/schemas/dist/transfer.js
+var DEFAULT_MAX_TRANSFER_DOCUMENTS = 2e4;
+var MAX_SUPPORTED_TRANSFER_BYTES = 512 * 1024 * 1024;
+var canonical32ByteValueSchema2 = base64UrlSchema.length(43).refine((value) => Buffer.from(value, "base64url").byteLength === 32, {
+  error: "Value must canonically encode exactly 32 bytes"
+});
+var transferKeySaltSchema = canonical32ByteValueSchema2.brand();
+var transferAuthenticationTagSchema = canonical32ByteValueSchema2.brand();
+var transferProtectionSchema = external_exports.object({
+  algorithm: external_exports.literal("argon2id+hkdf-sha256+xchacha20-poly1305-ietf"),
+  derivation: passphraseDerivationSchema,
+  expansionSalt: transferKeySaltSchema
+}).strict();
+var encryptedTransferHeaderSchema = external_exports.object({
+  type: external_exports.literal("header"),
+  format: external_exports.literal("kavrix-encrypted-transfer"),
+  version: external_exports.literal(1),
+  vaultId: vaultIdSchema,
+  schemaVersion: supportedSchemaVersionSchema,
+  createdAt: timestampSchema,
+  protection: transferProtectionSchema
+}).strict();
+var transferWithholdingReasonSchema = external_exports.enum([
+  /** The field definition sets `exportPolicy: 'never'`. */
+  "export-policy",
+  /** The value points at attachment content, which this format does not carry. */
+  "attachment-unsupported",
+  /** The value points at an item outside the exported set. */
+  "unresolved-reference"
+]);
+var transferWithholdingSchema = external_exports.object({
+  stableKey: stableFieldKeySchema,
+  scope: external_exports.enum(["template", "item"]),
+  reason: transferWithholdingReasonSchema
+}).strict();
+var transferWithholdingsSchema = external_exports.array(transferWithholdingSchema).max(2e3).superRefine((withholdings, context) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, withheld] of withholdings.entries()) {
+    const key = `${withheld.scope}:${withheld.stableKey}`;
+    if (seen.has(key)) {
+      context.addIssue({
+        code: "custom",
+        message: "A withholding manifest cannot name the same field twice",
+        path: [index, "stableKey"]
+      });
+    }
+    seen.add(key);
+  }
+});
+var encryptedTransferEntrySchema = external_exports.discriminatedUnion("kind", [
+  external_exports.object({
+    kind: external_exports.literal("group"),
+    groupId: groupIdSchema,
+    envelope: aeadEnvelopeSchema
+  }).strict(),
+  external_exports.object({
+    kind: external_exports.literal("item"),
+    groupId: groupIdSchema,
+    itemId: itemIdSchema,
+    envelope: aeadEnvelopeSchema,
+    withheld: transferWithholdingsSchema
+  }).strict()
+]);
+var encryptedTransferFooterSchema = external_exports.object({
+  type: external_exports.literal("footer"),
+  version: external_exports.literal(1),
+  groupCount: external_exports.number().int().nonnegative().max(DEFAULT_MAX_TRANSFER_DOCUMENTS),
+  itemCount: external_exports.number().int().nonnegative().max(DEFAULT_MAX_TRANSFER_DOCUMENTS),
+  transcriptSha256: canonical32ByteValueSchema2,
+  authenticationTag: transferAuthenticationTagSchema
+}).strict();
+var transferLimitsSchema = external_exports.object({
+  maximumBytes: external_exports.number().int().positive().max(MAX_SUPPORTED_TRANSFER_BYTES),
+  maximumDocuments: external_exports.number().int().positive().max(DEFAULT_MAX_TRANSFER_DOCUMENTS)
+}).strict();
+var transferCollisionStrategySchema = external_exports.enum(["fail", "skip", "rename"]);
+var transferImportSummarySchema = external_exports.object({
+  vaultId: vaultIdSchema,
+  createdAt: timestampSchema,
+  groupsCreated: external_exports.number().int().nonnegative(),
+  groupsSkipped: external_exports.number().int().nonnegative(),
+  itemsCreated: external_exports.number().int().nonnegative(),
+  withheldValues: external_exports.number().int().nonnegative()
+}).strict();
+
+export {
+  vaultIdSchema,
+  databaseIdSchema,
+  profileIdSchema,
+  keySlotIdSchema,
+  itemIdSchema,
+  attachmentIdSchema,
+  policyIdSchema,
+  grantIdSchema,
+  MAX_CIPHERTEXT_CHARS,
+  CURRENT_SCHEMA_VERSION,
+  CURRENT_CRYPTOGRAPHIC_VERSION,
+  timestampSchema,
+  keyVersionSchema,
+  supportedSchemaVersionSchema,
+  supportedCryptographicVersionSchema,
+  vaultRevisionSchema,
+  secretValueSchema,
+  sha256DigestSchema,
+  associatedDataSchema,
+  aeadEnvelopeSchema,
+  portableKeyDerivationSchema,
+  passphraseDerivationSchema,
+  recoveryKeyDerivationSchema,
+  keySlotSchema,
+  canonicalJson,
+  CLI_EXIT_CODES,
+  cliErrorCodeSchema,
+  exitCodeForCliError,
+  MAX_DATABASE_VAULTS,
+  databaseRevisionSchema,
+  databaseAssociatedDataSchema,
+  databaseAeadEnvelopeSchema,
+  databaseCatalogPayloadSchema,
+  databasePortableKeySlotSchema,
+  databaseRecoverySlotSchema,
+  encryptedDatabaseDocumentSchema,
+  databaseVaultDocumentSchema,
+  fileDatabaseContainerSchema,
+  fieldValueElementIdSchema,
+  fieldScalarValueSchema,
+  fieldValueMatchesDefinition,
+  itemPayloadSchema,
+  CURRENT_LOCAL_VAULT_VERSION,
+  MAX_LOCAL_RECOVERY_SLOTS,
+  localVaultPayloadSchema,
+  localVaultDocumentSchema,
+  MAX_AUTHORIZATION_STATE_BYTES,
+  environmentVariableNameSchema,
+  parseDurationToMs,
+  permissionEntrySchema,
+  normalizeProjectConfigAliases,
+  projectConfigDocumentSchema,
+  grantRecordSchema,
+  authorizationReasonSchema,
+  authorizationDecisionSchema,
+  runtimeAuditEventSchema,
+  authorizationStateDomainSchema,
+  authorizationEnvelopeContextSchema,
+  authorizationStateDocumentSchema,
+  authorizationStateEnvelopeSchema,
+  agentBrokerRequestSchema,
+  agentBrokerServerFrameSchema,
+  agentBrokerClientFrameSchema
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../packages/schemas/src/identifiers.ts", "../../../../packages/schemas/src/primitives.ts", "../../../../packages/schemas/src/encrypted-records.ts", "../../../../packages/schemas/src/content-hash.ts", "../../../../packages/schemas/src/fields.ts", "../../../../packages/schemas/src/notes.ts", "../../../../packages/schemas/src/templates.ts", "../../../../packages/schemas/src/payloads.ts", "../../../../packages/schemas/src/local-vault.ts", "../../../../packages/schemas/src/authorization.ts", "../../../../packages/schemas/src/sync.ts", "../../../../packages/schemas/src/api.ts", "../../../../packages/schemas/src/audit.ts", "../../../../packages/schemas/src/backup.ts", "../../../../packages/schemas/src/cli-contract.ts", "../../../../packages/schemas/src/database-container.ts", "../../../../packages/schemas/src/keychain.ts", "../../../../packages/schemas/src/policy.ts", "../../../../packages/schemas/src/rotation.ts", "../../../../packages/schemas/src/session-lifetime.ts", "../../../../packages/schemas/src/transfer.ts"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEO,IAAM,sBAAsB;AAC5B,IAAM,sBAAsB;AAC5B,IAAM,2BAA2B;AAExC,IAAM,kBAAkB,IAAI,OAAO,wBAAwB;AAC3D,IAAM,WAAW,iBACd,OAAM,EACN,IAAI,mBAAmB,EACvB,IAAI,mBAAmB,EACvB,MAAM,iBAAiB,8BAA8B;AAEjD,IAAM,gBAAgB,SAAS,MAAK;AACpC,IAAM,mBAAmB,SAAS,MAAK;AACvC,IAAM,kBAAkB,SAAS,MAAK;AACtC,IAAM,kBAAkB,SAAS,MAAK;AACtC,IAAM,gBAAgB,SAAS,MAAK;AACpC,IAAM,eAAe,SAAS,MAAK;AACnC,IAAM,gBAAgB,SAAS,MAAK;AACpC,IAAM,eAAe,SAAS,MAAK;AACnC,IAAM,mBAAmB,SAAS,MAAK;AACvC,IAAM,4BAA4B,SAAS,MAAK;AAChD,IAAM,iBAAiB,SAAS,MAAK;AACrC,IAAM,iBAAiB,SAAS,MAAK;AACrC,IAAM,qBAAqB,SAAS,MAAK;AACzC,IAAM,qBAAqB,SAAS,MAAK;AACzC,IAAM,kBAAkB,SAAS,MAAK;AACtC,IAAM,iBAAiB,SAAS,MAAK;AACrC,IAAM,iBAAiB,SAAS,MAAK;AACrC,IAAM,gBAAgB,SAAS,MAAK;;;AC5BpC,IAAM,iBAAiB;AACvB,IAAM,uBAAuB;AAC7B,IAAM,uBAAuB;AAC7B,IAAM,wBAAwB,OAAO;AAE5C,IAAM,cAAc,IAAI,YAAW;AAG7B,SAAU,eAAe,OAAa;AAC1C,SAAO,YAAY,OAAO,KAAK,EAAE;AACnC;AAGO,IAAM,qBAAqB,iBAAE,OAAM,EAAG,YAAY,CAAC,OAAO,YAAW;AAG1E,MAAI,MAAM,SAAS,kBAAkB,eAAe,KAAK,IAAI,gBAAgB;AAC3E,YAAQ,SAAS;MACf,MAAM;MACN,QAAQ;MACR,SAAS;MACT,WAAW;MACX,SAAS,sCAAsC,OAAO,cAAc,CAAC;KACtE;EACH;AACF,CAAC;AAEM,IAAM,yBAAyB;AAC/B,IAAM,4BAA4B,OAAO,OAAO;EACrD;CACQ;AACH,IAAM,gCAAgC;AACtC,IAAM,mCAAmC,OAAO,OAAO;EAC5D;CACQ;AACH,IAAM,wBAAwB;AAC9B,IAAM,2BAA2B,OAAO,OAAO,CAAC,qBAAqB,CAAU;AAE/E,IAAM,qCACX;AACK,IAAM,4BAA4B;AAClC,IAAM,qCACX;AACK,IAAM,gCAAgC;AAE7C,IAAM,4BAA4B,IAAI,OAAO,kCAAkC;AAC/E,IAAM,4BAA4B,IAAI,OAAO,kCAAkC;AAE/E,SAAS,kCAAkC,OAAa;AACtD,MAAI,MAAM,WAAW;AAAG,WAAO;AAC/B,QAAM,YAAY,MAAM,SAAS;AACjC,MAAI,cAAc;AAAG,WAAO;AAI5B,QAAM,aAAa,cAAc,IAAI,KAAK,IAAI,MAAM,QAAQ,CAAC,IAAI;AACjE,SAAO,0BAA0B,KAAK,MAAM,MAAM,CAAC,UAAU,CAAC;AAChE;AAEO,IAAM,kBAAkB,iBAAE,IAC9B,SAAS,EAAE,QAAQ,OAAO,WAAW,EAAC,CAAE,EACxC,OAAO,yBAAyB,EAChC,MAAM,yBAAyB;AAC3B,IAAM,iBAAiB,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW,EAAG,MAAK;AAC3D,IAAM,wBAAwB,iBAClC,OAAM,EACN,IAAG,EACH,SAAQ,EACR,IAAI,oBAAoB,EACxB,MAAK;AACR,IAAM,wBAAwB,iBAAE,OAAM,EAAG,IAAG,EAAG,SAAQ,EAAG,IAAI,oBAAoB;AAClF,IAAM,yBAAyB,iBAC5B,OAAM,EACN,IAAG,EACH,YAAW,EACX,IAAI,qBAAqB;AAMrB,IAAM,sBAAsB,sBAAsB,MAAK;AACvD,IAAM,mBAAmB,sBAAsB,MAAK;AACpD,IAAM,wBAAwB,sBAAsB,MAAK;AAEzD,IAAM,qBAAqB,sBAAsB,MAAK;AAEtD,IAAM,6BACX,sBAAsB,MAAK;AACtB,IAAM,+BAA+B,oBAAoB,OAC9D,CAAC,UAAU,0BAA0B,KAAK,CAAC,cAAc,UAAU,SAAS,GAC5E,EAAE,OAAO,6BAA4B,CAAE;AAElC,IAAM,sCAAsC,2BAA2B,OAC5E,CAAC,UAAU,iCAAiC,KAAK,CAAC,cAAc,UAAU,SAAS,GACnF,EAAE,OAAO,oCAAmC,CAAE;AAEzC,IAAM,8BAA8B,mBAAmB,OAC5D,CAAC,UAAU,yBAAyB,KAAK,CAAC,cAAc,UAAU,SAAS,GAC3E,EAAE,OAAO,4BAA2B,CAAE;AAEjC,IAAM,uBAAuB,uBAAuB,MAAK;AACzD,IAAM,sBAAsB,uBAAuB,MAAK;AACxD,IAAM,uBAAuB,uBAAuB,MAAK;AACzD,IAAM,wBAAwB,iBAAE,QAAQ,CAAC,EAAE,MAAK;AAChD,IAAM,8BAA8B,iBACxC,QAAQ,CAAC,EACT,MAAK;AACD,IAAM,uBAAuB,iBAAE,QAAQ,CAAC,EAAE,MAAK;AAC/C,IAAM,kBAAkB,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW;AACpD,IAAM,qBAAqB,iBAAE,OAAM,EAAG,KAAI,EAAG,IAAI,CAAC,EAAE,IAAI,GAAG;AAC3D,IAAM,sBAAsB;AAC5B,IAAM,oBAAoB,mBAAmB,MAAK;AAClD,IAAM,oBAAoB,iBAC9B,WAAW,UAAU,EACrB,OAAO,CAAC,UAAU,MAAM,aAAa,KAAK,MAAM,cAAc,gBAAgB;EAC7E,OAAO;CACR,EACA,MAAK;AAED,IAAM,kBAAkB,iBAC5B,OAAM,EACN,IAAI,CAAC,EACL,IAAI,oBAAoB,EACxB,MAAM,oBAAoB,sCAAsC,EAChE,OAAO,mCAAmC;EACzC,OAAO;CACR,EACA,OAAO,CAAC,UAAU,OAAO,KAAK,OAAO,WAAW,EAAE,SAAS,WAAW,MAAM,OAAO;EAClF,OAAO;CACR;AAEI,IAAM,qBAAqB,gBAC/B,OAAO,6BAA6B,EACpC,OAAO,CAAC,UAAU,OAAO,KAAK,OAAO,WAAW,EAAE,eAAe,IAAI;EACpE,OAAO;CACR,EACA,MAAK;AAED,IAAM,aAAa,iBACvB,OAAM,EACN,KAAI,EACJ,IAAI,CAAC,EACL,IAAI,GAAG,EACP,MAAM,+CAA+C,cAAc;;;ACtH/D,IAAM,4BAA4B,iBAAE,KAAK;EAC9C;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACD;AAEM,IAAM,gCAAgC,iBAAE,KAAK;EAClD;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACD;AAEM,IAAM,6BAA6B;AACnC,IAAM,0CAA0C;AAEvD,IAAM,2BAA2B,iBAC9B,OAAO;EACN,SAAS;EACT,eAAe;EACf,YAAY;EACZ,SAAS;EACT,UAAU,oBAAoB,SAAQ;EACtC,gBAAgB,mBAAmB,SAAQ;CAC5C,EACA,OAAM;AAET,IAAM,wBAAwB;EAC5B,SAAS,iBAAE,UAAS,EAAG,SAAQ;EAC/B,UAAU,iBAAE,UAAS,EAAG,SAAQ;;AAO3B,IAAM,uBAAuB,iBAAE,mBAAmB,cAAc;EACrE,yBAAyB,OAAO;IAC9B,YAAY,iBAAE,QAAQ,mBAAmB;IACzC,UAAU;IACV,SAAS,iBAAE,QAAQ,mBAAmB;IACtC,GAAG;GACJ;EACD,yBAAyB,OAAO;IAC9B,YAAY,iBAAE,QAAQ,OAAO;IAC7B,UAAU;IACV,SAAS,iBAAE,QAAQ,eAAe;IAClC,GAAG;GACJ;EACD,yBAAyB,OAAO;IAC9B,YAAY,iBAAE,QAAQ,MAAM;IAC5B,UAAU;IACV,SAAS,iBAAE,QAAQ,cAAc;IACjC,SAAS;IACT,UAAU,iBAAE,UAAS,EAAG,SAAQ;GACjC;EACD,yBAAyB,OAAO;IAC9B,YAAY,iBAAE,QAAQ,YAAY;IAClC,UAAU;IACV,SAAS,iBAAE,QAAQ,qBAAqB;IACxC,SAAS;IACT,UAAU;GACX;EACD,yBAAyB,OAAO;IAC9B,YAAY,iBAAE,QAAQ,kBAAkB;IACxC,UAAU;IACV,SAAS,iBAAE,QAAQ,kBAAkB;IACrC,SAAS;IACT,UAAU;GACX;EACD,yBAAyB,OAAO;IAC9B,YAAY,iBAAE,QAAQ,aAAa;IACnC,UAAU;IACV,SAAS,iBAAE,QAAQ,aAAa;IAChC,GAAG;GACJ;EACD,yBAAyB,OAAO;IAC9B,YAAY,iBAAE,QAAQ,SAAS;IAC/B,UAAU;IACV,SAAS,iBAAE,QAAQ,eAAe;IAClC,SAAS;IACT,UAAU;GACX;EACD,yBAAyB,OAAO;IAC9B,YAAY,iBAAE,QAAQ,cAAc;IACpC,UAAU;IACV,SAAS,iBAAE,QAAQ,cAAc;IACjC,GAAG;GACJ;EACD,yBAAyB,OAAO;IAC9B,YAAY,iBAAE,QAAQ,kBAAkB;IACxC,UAAU;IACV,SAAS,iBAAE,QAAQ,UAAU;IAC7B,GAAG;GACJ;EACD,yBAAyB,OAAO;IAC9B,YAAY,iBAAE,QAAQ,mBAAmB;IACzC,UAAU;IACV,SAAS,iBAAE,QAAQ,WAAW;IAC9B,GAAG;GACJ;EACD,yBAAyB,OAAO;IAC9B,YAAY,iBAAE,QAAQ,kBAAkB;IACxC,UAAU;IACV,SAAS,iBAAE,QAAQ,UAAU;IAC7B,SAAS;IACT,UAAU,iBAAE,UAAS,EAAG,SAAQ;GACjC;EACD,yBAAyB,OAAO;IAC9B,YAAY,iBAAE,QAAQ,wBAAwB;IAC9C,UAAU;IACV,SAAS,iBAAE,QAAQ,gBAAgB;IACnC,SAAS;IACT,UAAU;GACX;CACF;AAED,IAAM,8BAA8B,qBAAqB,YACvD,CAAC,gBAAgB,YAAW;AAC1B,MAAI,CAAC,6BAA6B,UAAU,eAAe,aAAa,EAAE,SAAS;AACjF,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,eAAe;KACvB;EACH;AACF,CAAC;AAGI,IAAM,qBAAqB,iBAC/B,OAAO;EACN,SAAS;EACT,WAAW,iBAAE,QAAQ,yBAAyB;EAC9C,OAAO;EACP,YAAY;EACZ,mBAAmB;EACnB,KAAK;EACL,YAAY;CACb,EACA,OAAM,EACN,YAAY,CAAC,UAAU,YAAW;AACjC,MAAI,SAAS,MAAM,WAAW,4BAA4B;AACxD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,OAAO;KACf;EACH;AACA,MAAI,SAAS,kBAAkB,WAAW,yCAAyC;AACjF,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,mBAAmB;KAC3B;EACH;AACA,MAAI,SAAS,eAAe,SAAS,IAAI,YAAY;AACnD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,YAAY;KACpB;EACH;AACF,CAAC;AAEI,IAAM,8CAA8C;AAEpD,IAAM,6BAA6B,mBAAmB,YAC3D,CAAC,UAAU,YAAW;AACpB,MAAI,SAAS,WAAW,SAAS,6CAA6C;AAC5E,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,YAAY;KACpB;EACH;AACA,MAAI,SAAS,IAAI,eAAe,gBAAgB;AAC9C,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,KAAK;KACb;EACH;AACF,CAAC;AAGI,IAAM,uCAAuC,IAAI,OAAO;AACxD,IAAM,oCAAoC;AAC1C,IAAM,wBAAwB;AAC9B,IAAM,wCAAwC,IAAI,OAAO,OAAO;AAChE,IAAM,wCACX,uCAAuC;AAClC,IAAM,yCACX,wCACA,wBAAwB;AACnB,IAAM,sCAAsC;AAC5C,IAAM,wCAAwC,KAAK,KACvD,oCAAoC,IAAK,CAAC;AAEtC,IAAM,wCAAwC,KAAK,KACvD,wCAAwC,IAAK,CAAC;AAGjD,IAAM,2BAA2B,gBAC9B,OAAO,mCAAmC,EAC1C,OAAO,CAAC,UAAU,OAAO,KAAK,OAAO,WAAW,EAAE,eAAe,IAAI;EACpE,OAAO;CACR;AACI,IAAM,kCAAkC,gBAC5C,IAAI,qCAAqC,EACzC,IAAI,qCAAqC,EACzC,OACC,CAAC,UAAS;AACR,QAAM,aAAa,OAAO,KAAK,OAAO,WAAW,EAAE;AACnD,SACE,cAAc,qCACd,cAAc;AAElB,GACA,EAAE,OAAO,mEAAkE,CAAE,EAE9E,MAAK;AAER,IAAM,uCAAuC,iBAAE,OAAO;EACpD,SAAS,iBAAE,QAAQ,CAAC;EACpB,WAAW,iBAAE,QAAQ,iCAAiC;EACtD,eAAe,iBAAE,QAAQ,CAAC;EAC1B,eAAe;EACf,YAAY;EACZ,SAAS;EACT,SAAS;EACT,QAAQ;EACR,cAAc;CACf;AAEM,IAAM,2CACX,qCACG,OAAO;EACN,YAAY,iBAAE,QAAQ,QAAQ;EAC9B,QAAQ;CACT,EACA,OAAM;AAEJ,IAAM,0CACX,qCACG,OAAO;EACN,YAAY,iBAAE,QAAQ,OAAO;EAC7B,OAAO,iBACJ,OAAM,EACN,IAAG,EACH,YAAW,EACX,IAAI,wBAAwB,CAAC;EAChC,YAAY;EACZ,KAAK,iBAAE,KAAK,CAAC,WAAW,OAAO,CAAC;CACjC,EACA,OAAM;AAEJ,IAAM,qCAAqC,iBAAE,mBAAmB,cAAc;EACnF;EACA;CACD;AAEM,IAAM,wCAAwC,iBAClD,OAAO;EACN,YAAY,iBAAE,QAAQ,mBAAmB;EACzC,QAAQ;EACR,gBAAgB;EAChB,aAAa;EACb,WAAW;EACX,WAAW;CACZ,EACA,OAAM;AAEF,IAAM,uCAAuC,iBACjD,OAAO;EACN,YAAY,iBAAE,QAAQ,kBAAkB;EACxC,QAAQ;EACR,gBAAgB,iBACb,OAAM,EACN,IAAG,EACH,YAAW,EACX,IAAI,oCAAoC;EAC3C,gBAAgB;EAChB,gBAAgB;EAChB,WAAW;EACX,WAAW;CACZ,EACA,OAAM,EACN,YAAY,CAAC,OAAO,YAAW;AAC9B,QAAM,kBAAkB,OAAO,KAC7B,MAAM,OAAO,YACb,WAAW,EACX;AACF,MAAI,oBAAoB,MAAM,iBAAiB,mCAAmC;AAChF,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,gBAAgB;KACxB;EACH;AACF,CAAC;AAII,IAAM,uCAAuC,qCACjD,OAAO;EACN,iBAAiB,iBAAE,QAAQ,CAAC;EAC5B,QAAQ;EACR,YAAY,iBAAE,OAAM,EAAG,IAAG,EAAG,SAAQ,EAAG,IAAI,qBAAqB;EACjE,qBAAqB,iBAClB,OAAM,EACN,IAAG,EACH,YAAW,EACX,IAAI,qCAAqC;EAC5C,iBAAiB;CAClB,EACA,OAAM;AAEF,IAAM,4BAA4B;AAClC,IAAM,gCAAgC;AACtC,IAAM,8BAA8B;AACpC,IAAM,wBAAwB;AAC9B,IAAM,wBAAwB;AAC9B,IAAM,oBAAoB;AAC1B,IAAM,oBAAoB;AAC1B,IAAM,yBAAyB;AAC/B,IAAM,yBAAyB;AAC/B,IAAM,gCAAgC;AAE7C,IAAM,iBAAiB,gBAAgB,OAAO,yBAAyB;AACvE,IAAM,qBAAqB,gBAAgB,OAAO,6BAA6B;AAExE,IAAM,8BAA8B,iBACxC,OAAO;EACN,WAAW,iBAAE,QAAQ,aAAa;EAClC,SAAS,iBAAE,QAAQ,CAAC;EACpB,MAAM;EACN,SAAS,iBAAE,QAAQ,gCAAgC;EACnD,cAAc,iBAAE,QAAQ,2BAA2B;CACpD,EACA,OAAM;AAEF,IAAM,6BAA6B,iBACvC,OAAO;EACN,WAAW,iBAAE,QAAQ,UAAU;EAC/B,SAAS,iBAAE,QAAQ,CAAC;EACpB,MAAM;EACN,WAAW,iBAAE,OAAM,EAAG,IAAG,EAAG,IAAI,qBAAqB,EAAE,IAAI,qBAAqB;EAChF,QAAQ,iBAAE,OAAM,EAAG,IAAG,EAAG,IAAI,iBAAiB,EAAE,IAAI,iBAAiB;EACrE,aAAa,iBACV,OAAM,EACN,IAAG,EACH,IAAI,sBAAsB,EAC1B,IAAI,sBAAsB;EAC7B,cAAc,iBAAE,QAAQ,2BAA2B;CACpD,EACA,OAAM;AAEF,IAAM,8BAA8B,iBACxC,OAAO;EACN,WAAW,iBAAE,QAAQ,aAAa;EAClC,SAAS,iBAAE,QAAQ,CAAC;EACpB,MAAM;EACN,SAAS,iBAAE,QAAQ,gCAAgC;EACnD,cAAc,iBAAE,QAAQ,2BAA2B;CACpD,EACA,OAAM;AAEF,IAAM,4BAA4B,iBACtC,OAAO;EACN,WAAW,iBAAE,QAAQ,aAAa;EAClC,SAAS,iBAAE,QAAQ,CAAC;EACpB,MAAM;EACN,SAAS,iBAAE,QAAQ,8BAA8B;EACjD,cAAc,iBAAE,QAAQ,2BAA2B;EACnD,UAAU,iBAAE,OAAM,EAAG,IAAI,CAAC,EAAE,IAAI,6BAA6B;CAC9D,EACA,OAAM;AAEF,IAAM,sBAAsB;AAC5B,IAAM,sBAAsB;AAEnC,IAAM,oBAAoB,iBAAE,OAAO;EACjC,aAAa;EACb,IAAI;EACJ,OAAO,iBAAE,KAAK,CAAC,WAAW,UAAU,cAAc,SAAS,CAAC;EAC5D,YAAY;EACZ,gBAAgB;EAChB,WAAW;EACX,cAAc,gBAAgB,SAAQ;EACtC,WAAW,gBAAgB,SAAQ;CACpC;AAEM,IAAM,gBAAgB,iBAC1B,mBAAmB,QAAQ;EAC1B,kBACG,OAAO;IACN,MAAM,iBAAE,QAAQ,cAAc;IAC9B,YAAY;GACb,EACA,OAAM;EACT,kBACG,OAAO;IACN,MAAM,iBAAE,QAAQ,YAAY;IAC5B,YAAY;GACb,EACA,OAAM;EACT,kBACG,OAAO;IACN,MAAM,iBAAE,QAAQ,cAAc;IAC9B,YAAY;GACb,EACA,OAAM;EACT,kBACG,OAAO;IACN,MAAM,iBAAE,QAAQ,YAAY;IAC5B,YAAY;IACZ,UAAU;GACX,EACA,OAAM;CACV,EACA,YAAY,CAAC,MAAM,YAAW;AAC7B,MAAI,KAAK,eAAe,IAAI,eAAe,oBAAoB;AAC7D,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,kBAAkB,OAAO,YAAY;KAC7C;EACH;AACA,MAAI,KAAK,eAAe,IAAI,aAAa,KAAK,IAAI;AAChD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,kBAAkB,OAAO,UAAU;KAC3C;EACH;AACA,MAAI,KAAK,eAAe,eAAe,KAAK,YAAY;AACtD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,kBAAkB,YAAY;KACtC;EACH;AACA,MAAI,KAAK,UAAU,aAAa,KAAK,cAAc,QAAW;AAC5D,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,WAAW;KACnB;EACH;AACA,MAAI,KAAK,UAAU,aAAa,KAAK,cAAc,QAAW;AAC5D,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,WAAW;KACnB;EACH;AACA,MAAI,KAAK,UAAU,gBAAgB,KAAK,iBAAiB,QAAW;AAClE,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,cAAc;KACtB;EACH;AACA,MAAI,KAAK,UAAU,gBAAgB,KAAK,iBAAiB,QAAW;AAClE,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,cAAc;KACtB;EACH;AACF,CAAC;AAEI,IAAM,oBAAoB,iBAC9B,OAAO;EACN,IAAI;EACJ,eAAe;EACf,sBAAsB;EACtB,UAAU,iBAAE,MAAM,aAAa,EAAE,IAAI,mBAAmB,EAAE,IAAI,mBAAmB;EACjF,mBAAmB;EACnB,UAAU;EACV,sBAAsB;EACtB,WAAW;EACX,WAAW;CACZ,EACA,OAAM,EACN,YAAY,CAAC,OAAO,YAAW;AAC9B,QAAM,MAAM,oBAAI,IAAG;AACnB,aAAW,CAAC,OAAO,IAAI,KAAK,MAAM,SAAS,QAAO,GAAI;AACpD,QAAI,KAAK,eAAe,IAAI,YAAY,MAAM,IAAI;AAChD,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,YAAY,OAAO,kBAAkB,OAAO,SAAS;OAC7D;IACH;AACA,QAAI,KAAK,eAAe,IAAI,kBAAkB,MAAM,eAAe;AACjE,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,YAAY,OAAO,kBAAkB,OAAO,eAAe;OACnE;IACH;AACA,QAAI,IAAI,IAAI,KAAK,EAAE,GAAG;AACpB,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,YAAY,OAAO,IAAI;OAC/B;IACH;AACA,QAAI,IAAI,KAAK,EAAE;EACjB;AACA,MAAI,CAAC,MAAM,SAAS,KAAK,CAAC,SAAS,KAAK,UAAU,QAAQ,GAAG;AAC3D,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,UAAU;KAClB;EACH;AACA,MACE,CAAC,MAAM,SAAS,KACd,CAAC,SACC,KAAK,UAAU,YAAY,KAAK,eAAe,MAAM,iBAAiB,GAE1E;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,mBAAmB;KAC3B;EACH;AACA,MACE,MAAM,qBAAqB,IAAI,YAAY,MAAM,MACjD,MAAM,qBAAqB,IAAI,eAAe,uBAC9C,MAAM,qBAAqB,IAAI,aAAa,MAAM,MAClD,MAAM,qBAAqB,IAAI,kBAAkB,MAAM,eACvD;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,wBAAwB,KAAK;KACrC;EACH;AACF,CAAC;AAEI,IAAM,6BAA6B,iBACvC,OAAO;EACN,IAAI;EACJ,SAAS;EACT,eAAe;EACf,iBAAiB;EACjB,kBAAkB;EAClB,iBAAiB;EACjB,gBAAgB;EAChB,WAAW;EACX,WAAW;EACX,cAAc,gBAAgB,SAAQ;CACvC,EACA,OAAM,EACN,YAAY,CAAC,QAAQ,YAAW;AAC/B,0BACE,SACA,OAAO,kBACP,OAAO,SACP,OAAO,eACP,SACA,OAAO,EAAE;AAEX,0BACE,SACA,OAAO,iBACP,OAAO,SACP,OAAO,eACP,qBACA,OAAO,EAAE;AAEb,CAAC;AAEI,IAAM,4BAA4B,iBACtC,OAAO;EACN,IAAI;EACJ,SAAS;EACT,SAAS;EACT,eAAe;EACf,gBAAgB;EAChB,kBAAkB;EAClB,gBAAgB;EAChB,gBAAgB;EAChB,WAAW;EACX,WAAW;EACX,cAAc,gBAAgB,SAAQ;CACvC,EACA,OAAM,EACN,YAAY,CAAC,QAAQ,YAAW;AAC/B,0BACE,SACA,OAAO,kBACP,OAAO,SACP,OAAO,eACP,QACA,OAAO,IACP,OAAO,OAAO;AAEhB,0BACE,SACA,OAAO,gBACP,OAAO,SACP,OAAO,eACP,oBACA,OAAO,IACP,OAAO,OAAO;AAElB,CAAC;AAEI,IAAM,kCAAkC,iBAC5C,OAAO;EACN,IAAI;EACJ,SAAS;EACT,SAAS;EACT,QAAQ;EACR,eAAe;EACf,sBAAsB;EACtB,mBAAmB;EACnB,YAAY,iBAAE,OAAM,EAAG,IAAG,EAAG,SAAQ,EAAG,IAAI,qBAAqB;EACjE,gBAAgB;EAChB,WAAW;EACX,WAAW;EACX,cAAc,gBAAgB,SAAQ;CACvC,EACA,OAAM,EACN,YAAY,CAAC,QAAQ,YAAW;AAC/B,0BACE,SACA,OAAO,mBACP,OAAO,SACP,OAAO,eACP,cACA,OAAO,IACP,OAAO,SACP,OAAO,MAAM;AAEf,0BACE,SACA,OAAO,sBACP,OAAO,SACP,OAAO,eACP,0BACA,OAAO,IACP,OAAO,SACP,OAAO,MAAM;AAEf,MACE,OAAO,qBAAqB,eAAe,OAAO,kBAAkB,YACpE;AACA,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,wBAAwB,YAAY;MAC3C,SAAS;KACV;EACH;AACF,CAAC;AAEI,IAAM,6BAA6B,iBACvC,OAAO;EACN,IAAI;EACJ,SAAS;EACT,eAAe;EACf,kBAAkB;EAClB,gBAAgB;EAChB,WAAW;CACZ,EACA,OAAM,EACN,YAAY,CAAC,QAAQ,YAAW;AAC/B,0BACE,SACA,OAAO,kBACP,OAAO,SACP,OAAO,eACP,eACA,OAAO,EAAE;AAEb,CAAC;AAEI,IAAM,+BAA+B,iBACzC,OAAO;EACN,IAAI;EACJ,SAAS;EACT,SAAS;EACT,QAAQ;EACR,eAAe;EACf,kBAAkB;EAClB,oBAAoB;EACpB,gBAAgB;EAChB,WAAW;CACZ,EACA,OAAM,EACN,YAAY,CAAC,QAAQ,YAAW;AAC/B,0BACE,SACA,OAAO,kBACP,OAAO,SACP,OAAO,eACP,WACA,OAAO,IACP,OAAO,SACP,OAAO,MAAM;AAEjB,CAAC;AAEI,IAAM,wBAAwB,iBAAE,MAAM;EAC3C;EACA;EACA;EACA;EACA;CACD;AAED,SAAS,wBACP,SACA,UACA,SACA,eACA,YACA,UACA,SACA,UAAiB;AAEjB,MACE,SAAS,IAAI,YAAY,WACzB,SAAS,IAAI,kBAAkB,iBAC/B,SAAS,IAAI,eAAe,cAC5B,SAAS,IAAI,aAAa,YAC1B,SAAS,IAAI,YAAY,WACzB,SAAS,IAAI,aAAa,UAC1B;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,KAAK;KACb;EACH;AACF;;;ACjxBA,SAAS,YAAY,uBAAuB;AAiB5C,IAAM,+BAA+B,OAAO,KAC1C,mCACA,MAAM;AA6DF,SAAU,cAAc,OAAc;AAC1C,MAAI,UAAU;AAAM,WAAO;AAC3B,MAAI,OAAO,UAAU,YAAY,OAAO,UAAU,WAAW;AAC3D,WAAO,KAAK,UAAU,KAAK;EAC7B;AACA,MAAI,OAAO,UAAU,UAAU;AAC7B,QAAI,CAAC,OAAO,SAAS,KAAK,GAAG;AAC3B,YAAM,IAAI,UAAU,4CAA4C;IAClE;AACA,WAAO,KAAK,UAAU,KAAK;EAC7B;AACA,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,WAAO,IAAI,MAAM,IAAI,CAAC,UAAU,cAAc,KAAK,CAAC,EAAE,KAAK,GAAG,CAAC;EACjE;AACA,MAAI,OAAO,UAAU,UAAU;AAC7B,UAAM,IAAI,UAAU,0CAA0C;EAChE;AAEA,QAAM,YAAY,OAAO,eAAe,KAAK;AAC7C,MAAI,cAAc,OAAO,aAAa,cAAc,MAAM;AACxD,UAAM,IAAI,UAAU,2CAA2C;EACjE;AACA,QAAM,SAAS;AACf,SAAO,IAAI,OAAO,KAAK,MAAM,EAC1B,KAAI,EACJ,OAAO,CAAC,QAAQ,OAAO,GAAG,MAAM,MAAS,EACzC,IAAI,CAAC,QAAQ,GAAG,KAAK,UAAU,GAAG,CAAC,IAAI,cAAc,OAAO,GAAG,CAAC,CAAC,EAAE,EACnE,KAAK,GAAG,CAAC;AACd;AAwBM,SAAU,4BACd,QAAuC;AAEvC,SAAO,mBAAmB,MACxB,WAAW,QAAQ,EAChB,OAAO,cAAc,OAAO,MAAM,GAAG,MAAM,EAC3C,OAAO,WAAW,CAAC;AAE1B;;;AC3HO,IAAM,kBAAkB,iBAAE,KAAK;EACpC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACD;AAED,IAAM,sBAAsB,oBAAI,IAAqC;EACnE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACD;AAEK,SAAU,qBACd,WAA0C;AAE1C,SAAO,oBAAoB,IAAI,SAAS;AAC1C;AAEO,IAAM,mBAAmB,iBAAE,KAAK,CAAC,SAAS,WAAW,SAAS,CAAC;AAC/D,IAAM,qBAAqB,iBAAE,KAAK,CAAC,SAAS,SAAS,SAAS,CAAC;AAC/D,IAAM,+BAA+B,iBAAE,KAAK,CAAC,SAAS,cAAc,QAAQ,CAAC;AAC7E,IAAM,qBAAqB,iBAAE,KAAK,CAAC,SAAS,kBAAkB,SAAS,CAAC;AAGxE,IAAM,wBAAwB,iBAAE,KAAK;EAC1C;EACA;EACA;EACA;EACA;EACA;CACD;AAEM,IAAM,wBAAwB,iBAClC,OAAO;EACN,WAAW,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW,EAAG,SAAQ;EAClD,WAAW,iBAAE,OAAM,EAAG,IAAG,EAAG,SAAQ,EAAG,IAAI,OAAS,EAAE,SAAQ;EAC9D,iBAAiB,sBAAsB,SAAQ;EAC/C,KAAK,iBAAE,OAAM,EAAG,SAAQ;EACxB,KAAK,iBAAE,OAAM,EAAG,SAAQ;EACxB,gBAAgB,iBAAE,MAAM,iBAAE,OAAM,EAAG,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,SAAQ;CACpE,EACA,OAAM,EACN,YAAY,CAAC,OAAO,YAAW;AAC9B,MACE,MAAM,cAAc,UACpB,MAAM,cAAc,UACpB,MAAM,YAAY,MAAM,WACxB;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,WAAW;KACnB;EACH;AACA,MAAI,MAAM,QAAQ,UAAa,MAAM,QAAQ,UAAa,MAAM,MAAM,MAAM,KAAK;AAC/E,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,KAAK;KACb;EACH;AACF,CAAC;AAEI,IAAM,qBAAqB,iBAC/B,OAAO;EACN,OAAO,iBAAE,OAAM,EAAG,IAAI,CAAC,EAAE,IAAI,GAAG;EAChC,OAAO;CACR,EACA,OAAM;AAET,IAAM,2BAA2B,iBAC9B,OAAM,EACN,IAAI,CAAC,EACL,IAAI,GAAG,EACP,MAAM,iCAAiC,8BAA8B;AAEjE,IAAM,4BACX,yBAAyB,MAAK;AAEhC,IAAM,0BAA0B,oBAAoB,OAClD,CAAC,UAAU,MAAM,SAAS,GAC1B,EAAE,OAAO,sCAAqC,CAAE;AAElD,IAAM,4BAA4B,kBAAkB,OAClD,CAAC,UAAU,MAAM,SAAS,GAC1B,EAAE,OAAO,wCAAuC,CAAE;AAG7C,IAAM,yBAAyB,iBAAE,mBAAmB,QAAQ;EACjE,iBAAE,OAAO,EAAE,MAAM,iBAAE,QAAQ,MAAM,GAAG,OAAO,wBAAuB,CAAE,EAAE,OAAM;EAC5E,iBAAE,OAAO,EAAE,MAAM,iBAAE,QAAQ,QAAQ,GAAG,OAAO,0BAAyB,CAAE,EAAE,OAAM;EAChF,iBAAE,OAAO,EAAE,MAAM,iBAAE,QAAQ,QAAQ,GAAG,OAAO,iBAAE,OAAM,EAAE,CAAE,EAAE,OAAM;EACjE,iBAAE,OAAO,EAAE,MAAM,iBAAE,QAAQ,SAAS,GAAG,OAAO,iBAAE,QAAO,EAAE,CAAE,EAAE,OAAM;EACnE,iBAAE,OAAO,EAAE,MAAM,iBAAE,QAAQ,gBAAgB,GAAG,QAAQ,aAAY,CAAE,EAAE,OAAM;EAC5E,iBACG,OAAO;IACN,MAAM,iBAAE,QAAQ,sBAAsB;IACtC,cAAc;GACf,EACA,OAAM;EACT,iBACG,OAAO;IACN,MAAM,iBAAE,QAAQ,mBAAmB;IACnC,KAAK,iBAAE,OAAM,EAAG,IAAI,CAAC,EAAE,IAAI,GAAG;IAC9B,OAAO,iBAAE,mBAAmB,kBAAkB;MAC5C,iBACG,OAAO;QACN,gBAAgB,iBAAE,QAAQ,MAAM;QAChC,OAAO;OACR,EACA,OAAM;MACT,iBACG,OAAO;QACN,gBAAgB,iBAAE,QAAQ,QAAQ;QAClC,OAAO;OACR,EACA,OAAM;KACV;GACF,EACA,OAAM;CACV;AAEM,IAAM,mCAAmC,iBAAE,mBAAmB,UAAU;EAC7E,iBACG,OAAO;IACN,SAAS,iBAAE,QAAQ,CAAC;IACpB,QAAQ,iBAAE,QAAQ,WAAW;IAC7B,QAAQ,iBAAE,UAAS,EAAG,SAAQ;GAC/B,EACA,OAAM;EACT,iBACG,OAAO;IACN,SAAS,iBAAE,QAAQ,CAAC;IACpB,QAAQ,iBAAE,QAAQ,MAAM;IACxB,QAAQ;GACT,EACA,OAAM;CACV;AAEM,IAAM,0BAA0B,iBACpC,OAAO;EACN,IAAI;EACJ,OAAO;EACP,WAAW;CACZ,EACA,OAAM;AAEF,IAAM,0BAA0B,iBACpC,mBAAmB,eAAe;EACjC,iBACG,OAAO;IACN,aAAa,iBAAE,QAAQ,QAAQ;IAC/B,OAAO;GACR,EACA,OAAM;EACT,iBACG,OAAO;IACN,aAAa,iBAAE,QAAQ,UAAU;IACjC,UAAU,iBAAE,MAAM,uBAAuB,EAAE,IAAI,CAAC,EAAE,IAAI,GAAM;GAC7D,EACA,OAAM,EACN,YAAY,CAAC,SAAS,YAAW;AAChC,UAAM,MAAM,oBAAI,IAAG;AACnB,UAAM,kBAAkB,oBAAI,IAAG;AAC/B,eAAW,CAAC,OAAO,OAAO,KAAK,QAAQ,SAAS,QAAO,GAAI;AACzD,UAAI,IAAI,IAAI,QAAQ,EAAE,GAAG;AACvB,gBAAQ,SAAS;UACf,MAAM;UACN,SAAS;UACT,MAAM,CAAC,YAAY,OAAO,IAAI;SAC/B;MACH;AACA,UAAI,IAAI,QAAQ,EAAE;AAClB,UAAI,QAAQ,MAAM,SAAS,qBAAqB;AAC9C,YAAI,gBAAgB,IAAI,QAAQ,MAAM,GAAG,GAAG;AAC1C,kBAAQ,SAAS;YACf,MAAM;YACN,SAAS;YACT,MAAM,CAAC,YAAY,OAAO,SAAS,KAAK;WACzC;QACH;AACA,wBAAgB,IAAI,QAAQ,MAAM,GAAG;MACvC;IACF;EACF,CAAC;CACJ,EACA,OACC,CAAC,UAAU,IAAI,YAAW,EAAG,OAAO,KAAK,UAAU,KAAK,CAAC,EAAE,cAAc,SACzE,EAAE,OAAO,uDAAsD,CAAE;AAG9D,IAAM,0BAA0B,iBACpC,OAAO,EAAE,SAAS,iBAAE,QAAQ,CAAC,GAAG,OAAO,iBAAE,QAAQ,SAAS,EAAC,CAAE,EAC7D,OAAM;AACF,IAAM,wBAAwB,iBAClC,OAAO,EAAE,SAAS,iBAAE,QAAQ,CAAC,GAAG,OAAO,iBAAE,QAAQ,OAAO,EAAC,CAAE,EAC3D,OAAM;AACF,IAAM,+BAA+B,iBACzC,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,OAAO,iBAAE,QAAQ,cAAc;EAC/B,QAAQ,iBAAE,OAAM,EAAG,KAAI,EAAG,IAAI,CAAC,EAAE,IAAI,GAAG,EAAE,SAAQ;CACnD,EACA,OAAM;AACF,IAAM,6BAA6B,iBACvC,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,OAAO,iBAAE,QAAQ,YAAY;EAC7B,QAAQ,iBAAE,KAAK;IACb;IACA;IACA;IACA;GACD;CACF,EACA,OAAM;AACF,IAAM,0BAA0B,iBACpC,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,OAAO,iBAAE,QAAQ,SAAS;EAC1B,SAAS;CACV,EACA,OAAM;AACF,IAAM,yBAAyB,iBAAE,mBAAmB,SAAS;EAClE;EACA;EACA;EACA;EACA;CACD;AACM,IAAM,2BAA2B,iBACrC,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,OAAO,iBAAE,QAAQ,UAAU;EAC3B,eAAe;CAChB,EACA,OAAM;AAEF,IAAM,mBAAmB,iBAC7B,mBAAmB,SAAS;EAC3B;EACA;EACA;EACA;EACA;EACA;CACD,EACA,OACC,CAAC,UAAU,IAAI,YAAW,EAAG,OAAO,KAAK,UAAU,KAAK,CAAC,EAAE,cAAc,SACzE,EAAE,OAAO,+CAA8C,CAAE;AAGtD,IAAM,uBAAuB,iBACjC,OAAM,EACN,IAAI,CAAC,EACL,IAAI,GAAG,EACP,MAAM,uCAAuC,0BAA0B;AAEnE,IAAM,wBAAwB,iBAClC,OAAO;EACN,IAAI;EACJ,WAAW;EACX,OAAO;EACP,aAAa,iBAAE,OAAM,EAAG,KAAI,EAAG,IAAI,IAAK,EAAE,SAAQ;EAClD,MAAM;EACN,UAAU,iBAAE,QAAO;EACnB,WAAW,iBAAE,QAAO;EACpB,YAAY,iBAAE,QAAO;EACrB,UAAU,iBAAE,QAAO;EACnB,mBAAmB,iBAAE,QAAO;EAC5B,eAAe,iBAAE,QAAO;EACxB,cAAc,wBAAwB,SAAQ;EAC9C,aAAa,iBAAE,OAAM,EAAG,IAAI,GAAG,EAAE,SAAQ;EACzC,iBAAiB,sBAAsB,SAAQ;EAC/C,eAAe,iBAAE,MAAM,kBAAkB,EAAE,IAAI,GAAK,EAAE,SAAQ;EAC9D,yBAAyB,iBACtB,OAAM,EACN,MAAM,0BAA0B,EAChC,IAAI,GAAG,EACP,SAAQ;EACX,YAAY;EACZ,cAAc;EACd,wBAAwB;EACxB,cAAc;EACd,WAAW;EACX,WAAW;EACX,WAAW;CACZ,EACA,OAAM,EACN,YAAY,CAAC,OAAO,YAAW;AAC9B,MAAI,MAAM,cAAc,MAAM,eAAe,UAAU;AACrD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,YAAY;KACpB;EACH;AACA,MAAI,MAAM,aAAa,MAAM,iBAAiB,QAAW;AACvD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,cAAc;KACtB;EACH;AACA,MAAI,qBAAqB,MAAM,IAAI,KAAK,CAAC,MAAM,WAAW;AACxD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,WAAW;KACnB;EACH;AACA,MAAI,MAAM,aAAa,MAAM,eAAe;AAC1C,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,eAAe;KACvB;EACH;AACA,MAAI,MAAM,aAAa,MAAM,2BAA2B,SAAS;AAC/D,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,wBAAwB;KAChC;EACH;AACA,MAAI,CAAC,MAAM,aAAa,MAAM,iBAAiB,SAAS;AACtD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,cAAc;KACtB;EACH;AACA,QAAM,WAAW,MAAM,SAAS,YAAY,MAAM,SAAS;AAC3D,MAAI,aAAa,CAAC,MAAM,iBAAiB,MAAM,cAAc,WAAW,IAAI;AAC1E,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,eAAe;KACvB;EACH;AACA,MAAI,CAAC,YAAY,MAAM,kBAAkB,QAAW;AAClD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,eAAe;KACvB;EACH;AACA,MACE,MAAM,iBAAiB,UACvB,CAAC,4BAA4B,OAAO,MAAM,YAAY,GACtD;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,cAAc;KACtB;EACH;AACF,CAAC;AAEI,IAAM,yBAAyB,iBACnC,OAAO;EACN,SAAS;EACT,WAAW;EACX,OAAO;EACP,WAAW;CACZ,EACA,OAAM;AAUF,IAAM,iCAAiC,iBAAE,KAAK;EACnD;EACA;EACA;CACD;AAEM,IAAM,2BAA2B,iBACrC,OAAO;EACN,YAAY;EACZ,OAAO;EACP,kBAAkB;EAClB,uBAAuB;EACvB,YAAY;EACZ,QAAQ;CACT,EACA,OAAM,EACN,YAAY,CAAC,UAAU,YAAW;AACjC,MACE,CAAC,4BAA4B,SAAS,YAAY,SAAS,MAAM,aAAa,GAC9E;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,SAAS,eAAe;KAChC;EACH;AACF,CAAC;AAEI,IAAM,sBAAsB,iBAChC,OAAO;EACN,QAAQ;EACR,cAAc,iBAAE,OAAM,EAAG,KAAI,EAAG,IAAI,CAAC,EAAE,IAAI,GAAG;CAC/C,EACA,OAAM;AAET,IAAM,uBAAuB,oBAAI,IAAe;EAC9C;EACA;EACA;EACA;CACD;AAQK,SAAU,2BAA2B,OAAsB;AAC/D,SAAO,MAAM,cAAc,qBAAqB,IAAI,MAAM,IAAI;AAChE;AAEM,SAAU,4BACd,OACA,OAAiB;AAEjB,MAAI,MAAM,UAAU;AAAY,WAAO;AACvC,MAAI,MAAM,UAAU;AAAW,WAAO,CAAC,MAAM;AAE7C,QAAM,kBAAkB,2BAA2B,KAAK;AACxD,MAAI,qBAAqB,MAAM,QAAQ,gBAAgB;AAAa,WAAO;AAC3E,QAAM,WACJ,MAAM,QAAQ,gBAAgB,aAAa,MAAM,QAAQ,WAAW;AACtE,MACE,MAAM,SAAS,wBACf,UAAU,KAAK,CAAC,EAAE,UAAS,MAAO,UAAU,WAAW,MAAM,MAAM,MACnE;AACA,WAAO;EACT;AACA,QAAM,aACJ,MAAM,QAAQ,gBAAgB,aAC1B,MAAM,QAAQ,SAAS,IAAI,CAAC,EAAE,OAAO,UAAS,MAAO,SAAS,IAC9D,CAAC,MAAM,QAAQ,KAAK;AAC1B,SAAO,WAAW,MAChB,CAAC,cACC,uBAAuB,OAAO,SAAS,KAAK,kBAAkB,OAAO,SAAS,CAAC;AAErF;AAEA,SAAS,uBACP,OACA,OAAuB;AAEvB,UAAQ,MAAM,MAAM;IAClB,KAAK;AACH,aAAO,MAAM,SAAS;IACxB,KAAK;AACH,aACE,MAAM,SAAS,YACf,OAAO,UAAU,MAAM,KAAK,KAC5B,MAAM,SAAS,KACf,MAAM,SAAS;IAEnB,KAAK;AACH,aAAO,MAAM,SAAS;IACxB,KAAK;AACH,aAAO,MAAM,SAAS;IACxB,KAAK;AACH,aAAO,MAAM,SAAS;IACxB,KAAK;AACH,aACE,MAAM,SAAS,uBACf,MAAM,MAAM,oBAAoB,MAAM,YAAY,WAAW;IAEjE,KAAK;AACH,UAAI,CAAC,mBAAmB,OAAO,KAAK;AAAG,eAAO;AAC9C,UAAI;AACF,aAAK,MAAM,MAAM,KAAK;AACtB,eAAO;MACT,QAAQ;AACN,eAAO;MACT;IACF,KAAK;IACL,KAAK;AACH,aAAO,mBAAmB,OAAO,KAAK,KAAK,kBAAkB,OAAO,MAAM,KAAK;IACjF,KAAK;AACH,aAAO,mBAAmB,OAAO,KAAK,KAAK,cAAc,MAAM,KAAK;IACtE,KAAK;AACH,UAAI,CAAC,mBAAmB,OAAO,KAAK;AAAG,eAAO;AAC9C,UAAI;AACF,cAAM,SAAS,IAAI,IAAI,MAAM,KAAK;AAClC,cAAM,UAAU,MAAM,iBAAiB;AACvC,eAAO,YAAY,UAAa,QAAQ,SAAS,OAAO,SAAS,MAAM,GAAG,EAAE,CAAC;MAC/E,QAAQ;AACN,eAAO;MACT;IACF;AACE,aAAO,mBAAmB,OAAO,KAAK;EAC1C;AACF;AAEA,SAAS,mBACP,OACA,OAAuB;AAEvB,SAAO,MAAM,YAAY,MAAM,SAAS,WAAW,MAAM,SAAS;AACpE;AAEA,SAAS,kBAAkB,OAAwB,OAAuB;AACxE,QAAM,QAAQ,MAAM;AACpB,MAAI,UAAU;AAAW,WAAO;AAChC,MAAI,MAAM,SAAS,UAAU,MAAM,SAAS,UAAU;AACpD,QAAI,MAAM,cAAc,UAAa,MAAM,MAAM,SAAS,MAAM;AAC9D,aAAO;AACT,QAAI,MAAM,cAAc,UAAa,MAAM,MAAM,SAAS,MAAM;AAC9D,aAAO;AACT,QACE,MAAM,oBAAoB,UAC1B,CAAC,uBAAuB,MAAM,iBAAiB,MAAM,KAAK;AAE1D,aAAO;EACX;AACA,MAAI,MAAM,SAAS,UAAU;AAC3B,QAAI,MAAM,QAAQ,UAAa,MAAM,QAAQ,MAAM;AAAK,aAAO;AAC/D,QAAI,MAAM,QAAQ,UAAa,MAAM,QAAQ,MAAM;AAAK,aAAO;EACjE;AACA,SAAO;AACT;AAEM,SAAU,uBACd,YACA,OAAa;AAEb,UAAQ,YAAY;IAClB,KAAK;AACH,aAAO,cAAc,OAAO,CAAC,SAAS,QAAQ,GAAI;IACpD,KAAK;AACH,aAAO,cACL,OACA,CAAC,SACE,QAAQ,MAAQ,QAAQ,OACxB,QAAQ,MAAQ,QAAQ,MACzB,SAAS,MACT,SAAS,EAAI;IAEnB,KAAK;AACH,aAAO,cACL,OACA,CAAC,SACE,QAAQ,MAAQ,QAAQ,MACxB,QAAQ,MAAQ,QAAQ,MACxB,QAAQ,MAAQ,QAAQ,GAAK;IAEpC,KAAK;AACH,aAAO,WAAW,KAAK;IACzB,KAAK;AACH,aAAO,OAAO,KAAK;IACrB,KAAK;AACH,aAAO,cACL,OACA,CAAC,SACE,QAAQ,MAAQ,QAAQ,MACxB,QAAQ,MAAQ,QAAQ,MACxB,QAAQ,MAAQ,QAAQ,OACzB,SAAS,MACT,SAAS,EAAI;EAErB;AACF;AAEA,SAAS,cAAc,OAAe,WAAoC;AACxE,MAAI,MAAM,WAAW;AAAG,WAAO;AAC/B,WAAS,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS,GAAG;AACpD,QAAI,CAAC,UAAU,MAAM,WAAW,KAAK,CAAC;AAAG,aAAO;EAClD;AACA,SAAO;AACT;AAEA,SAAS,WAAW,OAAa;AAC/B,MAAI,MAAM,WAAW,KAAK,MAAM,SAAS;AAAK,WAAO;AACrD,QAAM,SAAS,MAAM,MAAM,GAAG;AAC9B,SAAO,OAAO,MAAM,CAAC,UAAS;AAC5B,QAAI,MAAM,WAAW,KAAK,MAAM,SAAS;AAAI,aAAO;AACpD,QAAI,MAAM,WAAW,GAAG,KAAK,MAAM,SAAS,GAAG;AAAG,aAAO;AACzD,WAAO,cACL,OACA,CAAC,SACE,QAAQ,MAAQ,QAAQ,MACxB,QAAQ,MAAQ,QAAQ,MACxB,QAAQ,MAAQ,QAAQ,OACzB,SAAS,EAAI;EAEnB,CAAC;AACH;AAEA,SAAS,OAAO,OAAa;AAC3B,QAAM,QAAQ,MAAM,MAAM,GAAG;AAC7B,MAAI,MAAM,WAAW;AAAG,WAAO;AAC/B,SAAO,MAAM,MAAM,CAAC,SAAQ;AAC1B,QAAI,KAAK,WAAW,KAAK,KAAK,SAAS;AAAG,aAAO;AACjD,QAAI,KAAK,SAAS,KAAK,KAAK,WAAW,GAAG;AAAG,aAAO;AACpD,QAAI,CAAC,cAAc,MAAM,CAAC,SAAS,QAAQ,MAAQ,QAAQ,EAAI;AAAG,aAAO;AACzE,UAAM,QAAQ,OAAO,IAAI;AACzB,WAAO,SAAS,KAAK,SAAS;EAChC,CAAC;AACH;AAEA,SAAS,cAAc,OAAa;AAClC,QAAM,KAAK,MAAM,QAAQ,GAAG;AAC5B,MAAI,MAAM,KAAK,OAAO,MAAM,YAAY,GAAG;AAAG,WAAO;AACrD,QAAM,SAAS,MAAM,MAAM,KAAK,CAAC;AACjC,SAAO,OAAO,SAAS,GAAG,KAAK,CAAC,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,SAAS,GAAI;AAC7E;AAEA,SAAS,kBAAkB,OAAwB,OAAa;AAC9D,SAAO,MAAM,eAAe,KAAK,CAAC,WAAW,OAAO,UAAU,KAAK,MAAM;AAC3E;;;AC7pBO,IAAM,aAAa,iBACvB,OAAO;EACN,IAAI;EACJ,OAAO;EACP,SAAS;EACT,aAAa,iBAAE,QAAO;EACtB,UAAU,iBAAE,QAAO;EACnB,MAAM,iBAAE,MAAM,iBAAE,OAAM,EAAG,KAAI,EAAG,IAAI,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG;EACxD,WAAW;EACX,WAAW;EACX,WAAW;EACX,YAAY,gBAAgB,SAAQ;CACrC,EACA,OAAM;AAEF,IAAM,uBAAuB,iBACjC,MAAM,UAAU,EAChB,IAAI,GAAM,EACV,YAAY,CAAC,OAAO,YAAW;AAC9B,QAAM,MAAM,oBAAI,IAAG;AACnB,aAAW,CAAC,OAAO,IAAI,KAAK,MAAM,QAAO,GAAI;AAC3C,QAAI,IAAI,IAAI,KAAK,EAAE,GAAG;AACpB,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,OAAO,IAAI;OACnB;IACH;AACA,QAAI,IAAI,KAAK,EAAE;EACjB;AACF,CAAC;;;ACtBI,IAAM,2BAA2B,iBAAE,KAAK;EAC7C;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACD;AAEM,IAAM,sBAAsB,iBAChC,OAAO;EACN,IAAI;EACJ,MAAM;EACN,aAAa,iBAAE,OAAM,EAAG,KAAI,EAAG,IAAI,IAAK,EAAE,SAAQ;EAClD,YAAY,yBAAyB,SAAQ;EAC7C,SAAS;EACT,QAAQ,iBAAE,MAAM,qBAAqB,EAAE,IAAI,GAAK;EAChD,WAAW;EACX,WAAW;CACZ,EACA,OAAM,EACN,YAAY,CAAC,UAAU,YAAW;AACjC,QAAM,MAAM,oBAAI,IAAG;AACnB,QAAM,OAAO,oBAAI,IAAG;AACpB,QAAM,SAAS,oBAAI,IAAG;AACtB,aAAW,CAAC,OAAO,KAAK,KAAK,SAAS,OAAO,QAAO,GAAI;AACtD,QAAI,IAAI,IAAI,MAAM,EAAE,GAAG;AACrB,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,UAAU,OAAO,IAAI;OAC7B;IACH;AACA,QAAI,KAAK,IAAI,MAAM,SAAS,GAAG;AAC7B,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,UAAU,OAAO,WAAW;OACpC;IACH;AACA,QAAI,OAAO,IAAI,MAAM,SAAS,GAAG;AAC/B,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,UAAU,OAAO,WAAW;OACpC;IACH;AACA,QAAI,IAAI,MAAM,EAAE;AAChB,SAAK,IAAI,MAAM,SAAS;AACxB,WAAO,IAAI,MAAM,SAAS;EAC5B;AACF,CAAC;AAEH,IAAM,0BAA0B,iBAAE,OAAO;EACvC,mBAAmB,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW;EAC/C,sBAAsB,iBAAE,QAAO;CAChC;AAEM,IAAM,8BAA8B,iBAAE,mBAAmB,QAAQ;EACtE,wBAAwB,OAAO;IAC7B,MAAM,iBAAE,QAAQ,WAAW;IAC3B,OAAO;GACR;EACD,wBAAwB,OAAO;IAC7B,MAAM,iBAAE,QAAQ,eAAe;IAC/B,OAAO;GACR;EACD,wBAAwB,OAAO;IAC7B,MAAM,iBAAE,QAAQ,cAAc;IAC9B,SAAS;IACT,WAAW;IACX,SAAS;GACV;EACD,wBAAwB,OAAO;IAC7B,MAAM,iBAAE,QAAQ,eAAe;IAC/B,SAAS;IACT,eAAe;IACf,aAAa;GACd;EACD,wBAAwB,OAAO;IAC7B,MAAM,iBAAE,QAAQ,iBAAiB;IACjC,SAAS;IACT,cAAc,iBAAE,QAAO;IACvB,YAAY,iBAAE,QAAO;IACrB,mBAAmB,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW;GAChD;EACD,wBAAwB,OAAO;IAC7B,MAAM,iBAAE,QAAQ,qBAAqB;IACrC,SAAS;IACT,WAAW;IACX,SAAS;GACV;EACD,wBAAwB,OAAO;IAC7B,MAAM,iBAAE,QAAQ,cAAc;IAC9B,SAAS;IACT,WAAW;IACX,SAAS;IACT,UAAU;IACV,QAAQ;IACR,UAAU,iBAAE,KAAK;MACf;MACA;MACA;MACA;MACA;MACA;KACD;IACD,wBAAwB,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW;GACrD;EACD,wBAAwB,OAAO;IAC7B,MAAM,iBAAE,QAAQ,eAAe;IAC/B,OAAO;GACR;CACF;AAEM,IAAM,8BAA8B,iBACxC,OAAO;EACN,IAAI;EACJ,aAAa;EACb,WAAW;EACX,gBAAgB;EAChB,gBAAgB;EAChB,eAAe,iBACZ,MACC,iBACG,OAAO;IACN,QAAQ;IACR,UAAU;GACX,EACA,OAAM,CAAE,EAEZ,IAAI,GAAS;EAChB,OAAO,iBAAE,MAAM,2BAA2B,EAAE,IAAI,GAAK;EACrD,QAAQ,iBAAE,KAAK,CAAC,WAAW,WAAW,WAAW,CAAC;EAClD,eAAe,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW;EAC3C,YAAY,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW;EACxC,cAAc;EACd,WAAW;EACX,WAAW;CACZ,EACA,OAAM,EACN,YAAY,CAAC,MAAM,YAAW;AAC7B,MAAI,KAAK,aAAa,KAAK,aAAa;AACtC,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,WAAW;KACnB;EACH;AACA,MAAI,KAAK,eAAe,YAAY,KAAK,WAAW;AAClD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,kBAAkB,SAAS;KACnC;EACH;AACA,MAAI,KAAK,eAAe,YAAY,KAAK,aAAa;AACpD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,kBAAkB,SAAS;KACnC;EACH;AACA,MAAI,KAAK,eAAe,OAAO,KAAK,eAAe,IAAI;AACrD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,kBAAkB,IAAI;KAC9B;EACH;AACA,MAAI,KAAK,cAAc,WAAW,KAAK,YAAY;AACjD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,eAAe;KACvB;EACH;AACA,QAAM,cAAc,oBAAI,IAAG;AAC3B,aAAW,CAAC,OAAO,QAAQ,KAAK,KAAK,cAAc,QAAO,GAAI;AAC5D,QAAI,YAAY,IAAI,SAAS,MAAM,GAAG;AACpC,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,iBAAiB,OAAO,QAAQ;OACxC;IACH;AACA,gBAAY,IAAI,SAAS,MAAM;EACjC;AACA,MAAI,KAAK,gBAAgB,KAAK,YAAY;AACxC,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,eAAe;KACvB;EACH;AACA,MAAI,KAAK,WAAW,eAAe,KAAK,kBAAkB,KAAK,YAAY;AACzE,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,QAAQ;KAChB;EACH;AACF,CAAC;;;ACpMH,IAAM,gBAAgB,iBAAE,MAAM,iBAAE,OAAM,EAAG,KAAI,EAAG,IAAI,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG;AACxE,IAAM,aAAa,iBAAE,MAAM,iBAAE,OAAM,EAAG,KAAI,EAAG,IAAI,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG;AACrE,IAAM,uBAAuB,iBAC1B,OAAM,EACN,IAAI,CAAC,EACL,IAAI,GAAG,EACP,MAAM,+BAA+B,EACrC,MAAK;AAED,IAAM,qBAAqB,iBAC/B,OAAO;EACN,IAAI;EACJ,MAAM;EACN,WAAW,iBAAE,MAAM,oBAAoB,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;CACxD,EACA,OAAM,EACN,YAAY,CAAC,UAAU,YAAW;AACjC,QAAM,OAAO,oBAAI,IAAG;AACpB,aAAW,CAAC,OAAO,GAAG,KAAK,SAAS,UAAU,QAAO,GAAI;AACvD,QAAI,KAAK,IAAI,GAAG,GAAG;AACjB,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,aAAa,KAAK;OAC1B;IACH;AACA,SAAK,IAAI,GAAG;EACd;AACF,CAAC;AAEI,IAAM,qBAAqB,iBAC/B,OAAO;EACN,IAAI;EACJ,SAAS;EACT,MAAM;EACN,MAAM,WAAW,SAAQ;EACzB,SAAS;EACT,aAAa,iBAAE,OAAM,EAAG,KAAI,EAAG,IAAI,IAAK,EAAE,SAAQ;EAClD,MAAM,iBAAE,OAAM,EAAG,IAAI,EAAE,EAAE,SAAQ;EACjC,YAAY,iBAAE,OAAM,EAAG,IAAI,EAAE,EAAE,SAAQ;EACvC,MAAM;EACN,OAAO;EACP,UAAU;EACV,WAAW;EACX,UAAU;EACV,WAAW;EACX,WAAW;EACX,YAAY,gBAAgB,SAAQ;EACpC,WAAW,gBAAgB,SAAQ;CACpC,EACA,OAAM;AAEF,IAAM,sBAAsB,iBAChC,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,IAAI;EACJ,SAAS;EACT,SAAS;EACT,YAAY;EACZ,OAAO;EACP,MAAM,WAAW,SAAQ;EACzB,SAAS;EACT,UAAU,iBAAE,OAAM,EAAG,KAAI,EAAG,IAAI,GAAG,EAAE,SAAQ;EAC7C,iBAAiB;EACjB,gBAAgB,iBAAE,MAAM,sBAAsB,EAAE,IAAI,GAAK;EACzD,YAAY,iBAAE,MAAM,qBAAqB,EAAE,IAAI,GAAK;EACpD,YAAY,iBAAE,MAAM,sBAAsB,EAAE,IAAI,GAAK;EACrD,qBAAqB,iBAAE,MAAM,wBAAwB,EAAE,IAAI,GAAM;EACjE,OAAO;EACP,MAAM;EACN,UAAU,iBAAE,QAAO;EACnB,aAAa,iBAAE,OAAM,EAAG,KAAI,EAAG,IAAI,GAAG,EAAE,SAAQ;EAChD,OAAO,iBAAE,OAAM,EAAG,KAAI,EAAG,IAAI,CAAC,EAAE,IAAI,GAAG,EAAE,SAAQ;EACjD,SAAS,iBAAE,OAAM,EAAG,KAAI,EAAG,IAAI,CAAC,EAAE,IAAI,IAAK,EAAE,SAAQ;EACrD,qBAAqB,iBAAE,QAAO;EAC9B,WAAW,gBAAgB,SAAQ;EACnC,sBAAsB,iBAAE,OAAM,EAAG,IAAG,EAAG,SAAQ,EAAG,IAAI,KAAM,EAAE,SAAQ;EACtE,eAAe,gBAAgB,SAAQ;EACvC,gBAAgB,gBAAgB,SAAQ;EACxC,gBAAgB,iBAAE,MAAM,YAAY,EAAE,IAAI,GAAK;EAC/C,eAAe,iBAAE,MAAM,kBAAkB,EAAE,IAAI,GAAK;EACpD,eAAe,iBAAE,MAAM,kBAAkB,EAAE,IAAI,GAAG;EAClD,UAAU;EACV,WAAW;EACX,WAAW;EACX,YAAY,gBAAgB,SAAQ;EACpC,WAAW,gBAAgB,SAAQ;CACpC,EACA,OAAM,EACN,YAAY,CAAC,MAAM,YAAW;AAC7B,QAAM,WAAW,oBAAI,IAAG;AACxB,QAAM,aAAa,oBAAI,IAAG;AAC1B,QAAM,mBAAmB,oBAAI,IAAG;AAChC,QAAM,qBAAqB,oBAAI,IAAG;AAClC,aAAW,CAAC,OAAO,KAAK,KAAK;IAC3B,GAAG,KAAK;IACR,GAAG,KAAK;IACR,QAAO,GAAI;AACX,QAAI,SAAS,IAAI,MAAM,OAAO,KAAK,WAAW,IAAI,MAAM,SAAS,GAAG;AAClE,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,kBAAkB,KAAK;OAC/B;IACH;AACA,aAAS,IAAI,MAAM,OAAO;AAC1B,eAAW,IAAI,MAAM,SAAS;AAC9B,QAAI,QAAQ,KAAK,eAAe,QAAQ;AACtC,uBAAiB,IAAI,MAAM,OAAO;AAClC,yBAAmB,IAAI,MAAM,SAAS;IACxC;EACF;AAEA,QAAM,sBAAsB,oBAAI,IAAG;AACnC,QAAM,qBAAqB,oBAAI,IAAG;AAClC,aAAW,CAAC,OAAO,UAAU,KAAK,KAAK,WAAW,QAAO,GAAI;AAC3D,QACE,oBAAoB,IAAI,WAAW,EAAE,KACrC,mBAAmB,IAAI,WAAW,SAAS,KAC3C,iBAAiB,IAAI,WAAW,EAAE,KAClC,mBAAmB,IAAI,WAAW,SAAS,GAC3C;AACA,cAAQ,SAAS;QACf,MAAM;QACN,SACE;QACF,MAAM,CAAC,cAAc,KAAK;OAC3B;IACH;AACA,wBAAoB,IAAI,WAAW,IAAI,UAAU;AACjD,uBAAmB,IAAI,WAAW,SAAS;EAC7C;AACA,QAAM,eAAe,oBAAI,IAAG;AAC5B,aAAW,CAAC,OAAO,KAAK,KAAK,KAAK,WAAW,QAAO,GAAI;AACtD,UAAM,aAAa,oBAAoB,IAAI,MAAM,OAAO;AACxD,UAAM,oBACJ,YAAY,cAAc,MAAM,aAChC,4BAA4B,YAAY,MAAM,KAAK;AACrD,QAAI,aAAa,IAAI,MAAM,OAAO,KAAK,CAAC,mBAAmB;AACzD,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,cAAc,KAAK;OAC3B;IACH;AACA,iBAAa,IAAI,MAAM,OAAO;EAChC;AACA,aAAW,CAAC,OAAO,UAAU,KAAK,KAAK,WAAW,QAAO,GAAI;AAC3D,UAAM,SAAS,KAAK,WAAW,KAAK,CAAC,UAAU,MAAM,YAAY,WAAW,EAAE;AAC9E,QACE,WAAW,aACV,WAAW,UAAa,CAAC,4BAA4B,YAAY,OAAO,KAAK,IAC9E;AACA,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,cAAc,KAAK;OAC3B;IACH;EACF;AAEA,QAAM,sBAAsB,oBAAI,IAAI;IAClC,GAAG,KAAK,eAAe,IAAI,CAAC,EAAE,QAAO,MAAO,OAAO;IACnD,GAAG,KAAK,WAAW,IAAI,CAAC,EAAE,GAAE,MAAO,EAAE;GACtC;AACD,QAAM,uBAAuB,oBAAI,IAAI;IACnC,GAAG,KAAK,eAAe,IAAI,CAAC,EAAE,UAAS,MAAO,SAAS;IACvD,GAAG,KAAK,WAAW,IAAI,CAAC,EAAE,UAAS,MAAO,SAAS;GACpD;AACD,QAAM,cAAc,oBAAI,IAAG;AAC3B,QAAM,eAAe,oBAAI,IAAG;AAC5B,aAAW,CAAC,OAAO,QAAQ,KAAK,KAAK,oBAAoB,QAAO,GAAI;AAClE,QACE,YAAY,IAAI,SAAS,WAAW,EAAE,KACtC,aAAa,IAAI,SAAS,WAAW,SAAS,KAC9C,oBAAoB,IAAI,SAAS,WAAW,EAAE,KAC9C,qBAAqB,IAAI,SAAS,WAAW,SAAS,GACtD;AACA,cAAQ,SAAS;QACf,MAAM;QACN,SACE;QACF,MAAM,CAAC,uBAAuB,KAAK;OACpC;IACH;AACA,gBAAY,IAAI,SAAS,WAAW,EAAE;AACtC,iBAAa,IAAI,SAAS,WAAW,SAAS;EAChD;AAEA,QAAM,iBAAiB,oBAAI,IAAG;AAC9B,aAAW,CAAC,OAAO,aAAa,KAAK,KAAK,eAAe,QAAO,GAAI;AAClE,QAAI,kBAAkB,KAAK,MAAM,eAAe,IAAI,aAAa,GAAG;AAClE,cAAQ,SAAS;QACf,MAAM;QACN,SACE;QACF,MAAM,CAAC,kBAAkB,KAAK;OAC/B;IACH;AACA,mBAAe,IAAI,aAAa;EAClC;AACA,QAAM,gBAAgB,oBAAI,IAAG;AAC7B,aAAW,CAAC,OAAO,YAAY,KAAK,KAAK,cAAc,QAAO,GAAI;AAChE,QAAI,cAAc,IAAI,YAAY,GAAG;AACnC,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,iBAAiB,KAAK;OAC9B;IACH;AACA,kBAAc,IAAI,YAAY;EAChC;AAEA,aAAW,CAAC,gBAAgB,MAAM,KAAK;IACrC,CAAC,kBAAkB,KAAK,cAAc;IACtC,CAAC,cAAc,KAAK,UAAU;KACpB;AACV,eAAW,CAAC,YAAY,MAAM,KAAK,OAAO,QAAO,GAAI;AACnD,iBAAW,aAAa,mBAAmB,OAAO,KAAK,GAAG;AACxD,cAAM,QACJ,UAAU,SAAS,mBACf,eAAe,IAAI,UAAU,MAAM,IACnC,cAAc,IAAI,UAAU,YAAY;AAC9C,YAAI,CAAC,OAAO;AACV,kBAAQ,SAAS;YACf,MAAM;YACN,SAAS;YACT,MAAM,CAAC,gBAAgB,YAAY,OAAO;WAC3C;QACH;MACF;IACF;EACF;AAEA,QAAM,aAAa,oBAAI,IAAI;IACzB,GAAG,KAAK,eAAe,IAAI,CAAC,EAAE,UAAS,MAAO,SAAS;IACvD,GAAG,KAAK,WAAW,IAAI,CAAC,EAAE,UAAS,MAAO,SAAS;GACpD;AACD,QAAM,cAAc,oBAAI,IAAG;AAC3B,aAAW,CAAC,OAAO,QAAQ,KAAK,KAAK,cAAc,QAAO,GAAI;AAC5D,QAAI,YAAY,IAAI,SAAS,EAAE,GAAG;AAChC,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,iBAAiB,OAAO,IAAI;OACpC;IACH;AACA,gBAAY,IAAI,SAAS,EAAE;AAC3B,QAAI,SAAS,UAAU,KAAK,CAAC,QAAQ,CAAC,WAAW,IAAI,GAAG,CAAC,GAAG;AAC1D,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,iBAAiB,OAAO,WAAW;OAC3C;IACH;EACF;AACF,CAAC;AAEI,IAAM,oBAAoB;AAEjC,SAAS,mBACP,OAAuB;AAKvB,MAAI,MAAM,UAAU;AAAW,WAAO,CAAA;AACtC,QAAM,UACJ,MAAM,QAAQ,gBAAgB,WAC1B,CAAC,MAAM,QAAQ,KAAK,IACpB,MAAM,QAAQ,SAAS,IAAI,CAAC,EAAE,OAAO,OAAM,MAAO,MAAM;AAC9D,QAAM,aAGA,CAAA;AACN,aAAW,UAAU,SAAS;AAC5B,QAAI,OAAO,SAAS;AAAkB,iBAAW,KAAK,MAAM;AAC5D,QAAI,OAAO,SAAS;AAAwB,iBAAW,KAAK,MAAM;EACpE;AACA,SAAO;AACT;AAEO,IAAM,yBAAyB,iBACnC,OAAO;EACN,cAAc;EACd,gBAAgB,iBACb,OAAM,EACN,IAAI,CAAC,EACL,IAAI,EAAE,EACN,MAAM,kBAAkB;EAC3B,uBAAuB,iBAAE,OAAM,EAAG,IAAG,EAAG,IAAI,CAAC,EAAE,IAAI,IAAK;EACxD,mBAAmB,iBAAE,OAAM,EAAG,IAAG,EAAG,IAAI,CAAC,EAAE,IAAI,IAAK;EACpD,sBAAsB,iBAAE,OAAM,EAAG,IAAG,EAAG,IAAI,CAAC,EAAE,IAAI,KAAM;EACxD,kBAAkB,iBAAE,QAAQ,KAAK;CAClC,EACA,OAAM;;;ACpTF,IAAM,yBAAyB,iBAAE,QAAQ,oBAAoB;AAC7D,IAAM,8BAA8B;AACpC,IAAM,0BAA0B,iBAAE,QAAQ,2BAA2B;AACrE,IAAM,2BAA2B;AAEjC,IAAM,6BAA6B,cAAc,OACtD,CAAC,SAAS,KAAK,SAAS,gBACxB,EAAE,OAAO,qDAAoD,CAAE;AAG1D,IAAM,wBAAwB,iBAClC,OAAO;EACN,OAAO;EACP,WAAW;CACZ,EACA,OAAM;AAEF,IAAM,0BAA0B,iBACpC,OAAO;EACN,SAAS,iBAAE,OAAO,iBAAE,OAAM,EAAG,IAAI,CAAC,EAAE,IAAI,GAAG,GAAG,qBAAqB;CACpE,EACA,OAAM,EACN,YAAY,CAAC,SAAS,YAAW;AAChC,MAAI,OAAO,KAAK,QAAQ,OAAO,EAAE,SAAS,KAAQ;AAChD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,SAAS;KACjB;EACH;AACF,CAAC;AAEI,IAAM,2BAA2B,iBACrC,OAAO;EACN,QAAQ;EACR,SAAS;EACT,IAAI;EACJ,eAAe;EACf,sBAAsB;EACtB,mBAAmB;EACnB,SAAS;EACT,eAAe,iBACZ,MAAM,0BAA0B,EAChC,IAAI,wBAAwB,EAC5B,QAAQ,CAAA,CAAE;EACb,UAAU;EACV,kBAAkB;EAClB,WAAW;EACX,WAAW;CACZ,EACA,OAAM,EACN,YAAY,CAAC,UAAU,YAAW;AACjC,MAAI,SAAS,kBAAkB,wBAAwB;AACrD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,eAAe;KACvB;EACH;AACA,MAAI,SAAS,yBAAyB,+BAA+B;AACnE,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,sBAAsB;KAC9B;EACH;AAEA,MAAI,SAAS,QAAQ,SAAS,gBAAgB;AAC5C,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,WAAW,MAAM;KACzB;EACH,OAAO;AACL,QAAI,SAAS,QAAQ,UAAU,UAAU;AACvC,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,WAAW,OAAO;OAC1B;IACH;AACA,QAAI,SAAS,QAAQ,eAAe,SAAS,mBAAmB;AAC9D,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,WAAW,YAAY;OAC/B;IACH;AACA,QAAI,SAAS,QAAQ,eAAe,IAAI,YAAY,SAAS,IAAI;AAC/D,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,WAAW,kBAAkB,OAAO,SAAS;OACrD;IACH;EACF;AAEA,QAAM,UAAU,oBAAI,IAAI,CAAC,SAAS,QAAQ,EAAE,CAAC;AAC7C,aAAW,CAAC,OAAO,IAAI,KAAK,SAAS,cAAc,QAAO,GAAI;AAC5D,QAAI,QAAQ,IAAI,KAAK,EAAE,GAAG;AACxB,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,iBAAiB,OAAO,IAAI;OACpC;IACH;AACA,YAAQ,IAAI,KAAK,EAAE;AACnB,QAAI,KAAK,eAAe,SAAS,mBAAmB;AAClD,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,iBAAiB,OAAO,YAAY;OAC5C;IACH;AACA,QAAI,KAAK,eAAe,IAAI,YAAY,SAAS,IAAI;AACnD,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,iBAAiB,OAAO,kBAAkB,OAAO,SAAS;OAClE;IACH;AACA,QAAI,KAAK,eAAe,IAAI,kBAAkB,SAAS,eAAe;AACpE,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,iBAAiB,OAAO,kBAAkB,OAAO,eAAe;OACxE;IACH;AACA,QAAI,KAAK,UAAU,YAAY,KAAK,UAAU,WAAW;AACvD,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,iBAAiB,OAAO,OAAO;OACvC;IACH;EACF;AAEA,QAAM,MAAM,SAAS,iBAAiB;AACtC,MACE,IAAI,aAAa,UACjB,IAAI,mBAAmB,UACvB,IAAI,aAAa,SAAS,UAC1B;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,oBAAoB,KAAK;KACjC;EACH;AACA,MACE,IAAI,YAAY,SAAS,MACzB,IAAI,aAAa,SAAS,MAC1B,IAAI,kBAAkB,SAAS,iBAC/B,IAAI,eAAe,SAAS,mBAC5B;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,oBAAoB,KAAK;KACjC;EACH;AACF,CAAC;;;AC9KI,IAAM,mBAAmB,OAAO,OAAO;EAC5C;EACA;EACA;CACQ;AACH,IAAM,iBAAiB;AACvB,IAAM,iBAAiB,iBAAiB;AAExC,IAAM,iBAAiB,iBAAE,KAAK,gBAAgB;AAC9C,IAAM,kBAAkB,iBAC5B,MAAM,cAAc,EACpB,IAAI,cAAc,EAClB,IAAI,cAAc,EAClB,YAAY,CAAC,QAAQ,YAAW;AAC/B,MAAI,IAAI,IAAI,MAAM,EAAE,SAAS,OAAO,QAAQ;AAC1C,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;KACV;EACH;AACF,CAAC;;;ACaI,IAAM,4BAA4B;AAClC,IAAM,4BAA4B;AAElC,IAAM,uBAAuB,iBAAE,KAAK,CAAC,SAAS,SAAS,QAAQ,YAAY,CAAC;AAC5E,IAAM,sBAAsB,iBAAE,KAAK,CAAC,UAAU,aAAa,WAAW,OAAO,CAAC;AAErF,IAAM,yBAAyB,iBAC5B,OAAO;EACN,IAAI;EACJ,SAAS;EACT,gBAAgB;EAChB,gBAAgB;EAChB,WAAW;EACX,gBAAgB,mBAAmB,SAAQ;EAC3C,WAAW;CACZ,EACA,OAAM;AAEF,IAAM,qBAAqB,iBAC/B,mBAAmB,cAAc;EAChC,uBAAuB,OAAO;IAC5B,YAAY,iBAAE,QAAQ,OAAO;IAC7B,UAAU;GACX;EACD,uBAAuB,OAAO;IAC5B,YAAY,iBAAE,QAAQ,OAAO;IAC7B,UAAU;GACX;EACD,uBAAuB,OAAO;IAC5B,YAAY,iBAAE,QAAQ,MAAM;IAC5B,UAAU;GACX;EACD,uBAAuB,OAAO;IAC5B,YAAY,iBAAE,QAAQ,YAAY;IAClC,UAAU;GACX;CACF,EACA,YAAY,CAAC,QAAQ,YAAW;AAC/B,MAAI,OAAO,mBAAmB,GAAG;AAC/B,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,gBAAgB;KACxB;EACH;AACA,MAAI,OAAO,cAAc,WAAW,OAAO,mBAAmB,QAAW;AACvE,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,gBAAgB;KACxB;EACH;AACA,MAAI,OAAO,eAAe,WAAW,OAAO,aAAa,OAAO,SAAS;AACvE,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,UAAU;KAClB;EACH;AACF,CAAC;AAEH,IAAM,iCAAiC,iBACpC,OAAO;EACN,IAAI;EACJ,SAAS;EACT,eAAe;EACf,cAAc;EACd,gBAAgB,2BAA2B,SAAQ;EACnD,QAAQ;EACR,WAAW;EACX,YAAY,gBAAgB,SAAQ;EACpC,WAAW,gBAAgB,SAAQ;CACpC,EACA,OAAM;AAET,SAAS,sBACP,QACA,SAAwB;AAExB,MACE,OAAO,mBAAmB,WACzB,OAAO,eAAe,IAAI,YAAY,OAAO,WAC5C,OAAO,eAAe,IAAI,kBAAkB,OAAO,iBACnD,OAAO,eAAe,IAAI,eAAe,kBACzC,OAAO,eAAe,IAAI,aAAa,OAAO,KAChD;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,kBAAkB,KAAK;KAC/B;EACH;AACF;AAGO,IAAM,2BACX,+BAA+B,YAAY,qBAAqB;AAG3D,IAAM,qBAAqB,+BAC/B,OAAO,EAAE,WAAW,mBAAkB,CAAE,EACxC,YAAY,qBAAqB;AAE7B,IAAM,gCAAgC,iBAAE,KAAK;EAClD;EACA;CACD;AAED,IAAM,yCAAyC,iBAC5C,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,MAAM;EACN,qBAAqB,iBAClB,OAAM,EACN,IAAI,yBAAyB,EAC7B,IAAI,yBAAyB;EAChC,aAAa;EACb,cAAc;EACd,uBAAuB;EACvB,0BAA0B;EAC1B,+BAA+B;CAChC,EACA,OAAM;AAET,SAAS,4BACP,aACA,SAAwB;AAExB,MACE,YAAY,gCAAgC,YAAY,0BACxD;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,+BAA+B;KACvC;EACH;AACF;AAEO,IAAM,mCACX,uCAAuC,YAAY,2BAA2B;AAEzE,IAAM,4BAA4B,uCACtC,OAAO,EAAE,eAAe,mBAAkB,CAAE,EAC5C,OAAM,EACN,YAAY,2BAA2B;AAEnC,IAAM,kCAAkC,iBAC5C,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,SAAS;EACT,UAAU;EACV,0BAA0B;EAC1B,WAAW;EACX,qBAAqB,0BAA0B,SAAQ;EACvD,4BAA4B,mBAAmB,SAAQ;CACxD,EACA,OAAM,EACN,YAAY,CAAC,OAAO,YAAW;AAC9B,MACE,MAAM,wBAAwB,UAC9B,MAAM,oBAAoB,wBAAwB,MAAM,0BACxD;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,0BAA0B;KAClC;EACH;AACF,CAAC;AAEH,IAAM,4BAA4B,iBAC/B,OAAO;EACN,SAAS;EACT,OAAO,iBAAE,KAAK,CAAC,WAAW,UAAU,CAAC;EACrC,mBAAmB;EACnB,oBAAoB;EACpB,oBAAoB;EACpB,WAAW;EACX,YAAY,gBAAgB,SAAQ;EACpC,YAAY,gBAAgB,SAAQ;CACrC,EACA,OAAM;AAEF,IAAM,wBAAwB,iBAClC,mBAAmB,cAAc;EAChC,0BAA0B,OAAO;IAC/B,YAAY,iBAAE,QAAQ,OAAO;IAC7B,UAAU;GACX;EACD,0BAA0B,OAAO;IAC/B,YAAY,iBAAE,QAAQ,OAAO;IAC7B,UAAU;GACX;EACD,0BAA0B,OAAO;IAC/B,YAAY,iBAAE,QAAQ,MAAM;IAC5B,UAAU;GACX;EACD,0BAA0B,OAAO;IAC/B,YAAY,iBAAE,QAAQ,YAAY;IAClC,UAAU;GACX;CACF,EACA,YAAY,CAAC,WAAW,YAAW;AAClC,MAAI,UAAU,qBAAqB,UAAU,oBAAoB;AAC/D,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,mBAAmB;KAC3B;EACH;AACA,MAAI,UAAU,eAAe,WAAW,UAAU,aAAa,UAAU,SAAS;AAChF,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,UAAU;KAClB;EACH;AACA,MAAI,UAAU,UAAU,cAAc,UAAU,eAAe,QAAW;AACxE,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,YAAY;KACpB;EACH;AACA,MAAI,UAAU,UAAU,aAAa,UAAU,eAAe,QAAW;AACvE,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,YAAY;KACpB;EACH;AACA,MAAI,UAAU,UAAU,cAAc,UAAU,eAAe,QAAW;AACxE,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,YAAY;KACpB;EACH;AACF,CAAC;AAEI,IAAM,uBAAuB,iBAAE,mBAAmB,cAAc;EACrE,iBACG,OAAO;IACN,YAAY,iBAAE,QAAQ,OAAO;IAC7B,uBAAuB,oBAAoB,SAAQ;IACnD,gBAAgB,iBACb,OAAM,EACN,IAAI,yBAAyB,EAC7B,IAAI,yBAAyB;IAChC,QAAQ;GACT,EACA,OAAM;EACT,iBACG,OAAO;IACN,YAAY,iBAAE,QAAQ,OAAO;IAC7B,wBAAwB,qBAAqB,SAAQ;IACrD,gBAAgB,iBACb,OAAM,EACN,IAAI,yBAAyB,EAC7B,IAAI,yBAAyB;IAChC,QAAQ;GACT,EACA,OAAM;EACT,iBACG,OAAO;IACN,YAAY,iBAAE,QAAQ,MAAM;IAC5B,wBAAwB,qBAAqB,SAAQ;IACrD,gBAAgB,iBACb,OAAM,EACN,IAAI,yBAAyB,EAC7B,IAAI,yBAAyB;IAChC,QAAQ;GACT,EACA,OAAM;CACV;AAEM,IAAM,mCAAmC,iBAC7C,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,gBAAgB,iBACb,OAAM,EACN,IAAI,yBAAyB,EAC7B,IAAI,yBAAyB;EAChC,4BAA4B,qBAAqB,SAAQ;EACzD,QAAQ;CACT,EACA,OAAM,EACN,YAAY,CAAC,OAAO,YAAW;AAC9B,QAAM,sBACJ,MAAM,+BAA+B,OACjC,IACA,MAAM,6BAA6B;AACzC,MAAI,MAAM,OAAO,mBAAmB,qBAAqB;AACvD,YAAQ,SAAS;MACf,MAAM;MACN,SACE;MACF,MAAM,CAAC,UAAU,gBAAgB;KAClC;EACH;AACA,MAAI,4BAA4B,MAAM,MAAM,MAAM,MAAM,OAAO,aAAa;AAC1E,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,UAAU,aAAa;KAC/B;EACH;AACF,CAAC;AAEH,IAAM,yCAAyC,iBAAE,OAAO;EACtD,SAAS,iBAAE,QAAQ,CAAC;EACpB,gBAAgB,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW,EAAG,IAAI,qBAAqB;EACxE,qBAAqB,iBAClB,OAAM,EACN,IAAG,EACH,YAAW,EACX,IAAI,qCAAqC;EAC5C,sBAAsB,iBACnB,OAAM,EACN,IAAG,EACH,YAAW,EACX,IAAI,sCAAsC;CAC9C;AAEM,IAAM,iCAAiC,iBAC3C,mBAAmB,SAAS;EAC3B,uCACG,OAAO;IACN,OAAO,iBAAE,QAAQ,OAAO;IACxB,gBAAgB,iBAAE,QAAQ,CAAC;IAC3B,qBAAqB,iBAAE,QAAQ,CAAC;IAChC,sBAAsB,iBAAE,QAAQ,CAAC;GAClC,EACA,OAAM;EACT,uCACG,OAAO;IACN,OAAO,iBAAE,QAAQ,SAAS;IAC1B,gBAAgB,iBAAE,OAAM,EAAG,IAAG,EAAG,SAAQ,EAAG,IAAI,qBAAqB;IACrE,gBAAgB,iBACb,OAAM,EACN,IAAG,EACH,YAAW,EACX,IAAI,wBAAwB,CAAC;IAChC,yBAAyB;IACzB,yBAAyB,iBACtB,OAAM,EACN,IAAG,EACH,YAAW,EACX,IAAI,oCAAoC;GAC5C,EACA,OAAM;EACT,uCACG,OAAO;IACN,OAAO,iBAAE,QAAQ,mBAAmB;IACpC,gBAAgB,iBAAE,OAAM,EAAG,IAAG,EAAG,SAAQ,EAAG,IAAI,qBAAqB;IACrE,gBAAgB,iBACb,OAAM,EACN,IAAG,EACH,YAAW,EACX,IAAI,wBAAwB,CAAC;IAChC,yBAAyB;IACzB,yBAAyB,iBACtB,OAAM,EACN,IAAG,EACH,YAAW,EACX,IAAI,oCAAoC;GAC5C,EACA,OAAM;CACV,EACA,YAAY,CAAC,UAAU,YAAW;AACjC,MAAI,SAAS,UAAU;AAAS;AAChC,MACE,SAAS,UAAU,aACnB,SAAS,mBAAmB,uBAC5B;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,OAAO;KACf;EACH;AACA,MAAI,SAAS,mBAAmB,SAAS,iBAAiB,GAAG;AAC3D,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,gBAAgB;KACxB;EACH;AACA,MACE,SAAS,yBACT,SAAS,sBACP,SAAS,iBAAiB,mCAC5B;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,sBAAsB;KAC9B;EACH;AACF,CAAC;AAEI,IAAM,sCAAsC,iBAChD,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,QAAQ;CACT,EACA,OAAM;AAEF,IAAM,mBAAmB,iBAC7B,OAAO;EACN,SAAS;EACT,gBAAgB;EAChB,0BAA0B;CAC3B,EACA,OAAM;AAEF,IAAM,kBAAkB,iBAAE,KAAK;EACpC;EACA;EACA;EACA;EACA;CACD;AAEM,IAAM,uCAAuC,iBAAE,KAAK;EACzD;EACA;CACD;AAEM,IAAM,+BAA+B,iBACzC,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,UAAU;EACV,iBAAiB,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW,EAAG,IAAI,OAAO,gBAAgB;EAC3E,2BAA2B,iBAAE,OAAM,EAAG,SAAQ;EAC9C,YAAY;CACb,EACA,OAAM;;;AC7aF,IAAM,uBAAuB,iBAAE,OAAO,EAAE,QAAQ,iBAAE,QAAQ,IAAI,EAAC,CAAE,EAAE,OAAM;AACzE,IAAM,0BAA0B,iBACpC,OAAO,EAAE,QAAQ,iBAAE,KAAK,CAAC,SAAS,WAAW,CAAC,EAAC,CAAE,EACjD,OAAM;AAEF,IAAM,8BAA8B;AACpC,IAAM,iCAAiC;AACvC,IAAM,6BAA6B;AACnC,IAAM,gCAAgC;AACtC,IAAM,0BAA0B;AAChC,IAAM,iCAAiC;AACvC,IAAM,6BAA6B;AAG1C,IAAM,qCAAqC,iBACxC,OAAO;EACN,SAAS,iBAAE,QAAQ,2BAA2B;EAC9C,SAAS;EACT,WAAW;CACZ,EACA,OAAM;AAEF,IAAM,iCAAiC,iBAAE,mBAAmB,YAAY;EAC7E,mCACG,OAAO;IACN,UAAU,iBAAE,QAAQ,SAAS;IAC7B,IAAI;GACL,EACA,OAAM;EACT,mCACG,OAAO;IACN,UAAU,iBAAE,QAAQ,SAAS;IAC7B,IAAI;GACL,EACA,OAAM;CACV;AAED,IAAM,iCAAiC,iBACpC,OAAM,EACN,IAAI,CAAC,EACL,IAAI,6BAA6B,EACjC,KAAK,eAAe,EACpB,MAAK;AAEF,SAAU,wBACd,SAAuD;AAEvD,QAAM,gBAAgB,+BAA+B,MAAM,OAAO;AAClE,SAAO,+BAA+B,MACpC,OAAO,KAAK,cAAc,aAAa,GAAG,MAAM,EAAE,SAAS,WAAW,CAAC;AAE3E;AAEA,SAAS,iCACP,QAAe;AAEf,MAAI;AACF,UAAM,eAAe,+BAA+B,MAAM,MAAM;AAChE,UAAM,OAAO,IAAI,YAAY,SAAS,EAAE,OAAO,KAAI,CAAE,EAAE,OACrD,OAAO,KAAK,cAAc,WAAW,CAAC;AAExC,UAAM,UAAU,+BAA+B,MAAM,KAAK,MAAM,IAAI,CAAY;AAChF,QAAI,wBAAwB,OAAO,MAAM,cAAc;AACrD,YAAM,IAAI,UAAU,kCAAkC;IACxD;AACA,WAAO;EACT,QAAQ;AACN,UAAM,IAAI,UAAU,6BAA6B;EACnD;AACF;AAEM,SAAU,wBACd,QAAc;AAEd,SAAO,iCAAiC,MAAM;AAChD;AAEO,IAAM,0BAA0B,+BAA+B,YACpE,CAAC,QAAQ,YAAW;AAClB,MAAI;AACF,qCAAiC,MAAM;EACzC,QAAQ;AACN,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;KACV;EACH;AACF,CAAC;AAGI,IAAM,uBAAuB,iBACjC,OAAM,EACN,OAAO,EAAE,EACT,MAAM,oBAAoB,gDAAgD,EAC1E,OAAO,CAAC,UAAU,OAAO,KAAK,OAAO,WAAW,EAAE,SAAS,WAAW,MAAM,OAAO;EAClF,OAAO;CACR,EACA,MAAK;AAED,IAAM,yBAAyB,iBACnC,OAAO;EACN,OAAO,iBACJ,OAAO;IACN,MAAM,iBAAE,OAAM,EAAG,IAAI,CAAC,EAAE,IAAI,EAAE;IAC9B,SAAS,iBAAE,OAAM,EAAG,IAAI,CAAC,EAAE,IAAI,GAAG;IAClC,UAAU,iBACP,OAAO;MACN,YAAY,iBAAE,KAAK,CAAC,SAAS,SAAS,QAAQ,YAAY,CAAC;MAC3D,UAAU,iBAAE,OAAM,EAAG,IAAI,CAAC,EAAE,IAAI,GAAG;MACnC,kBAAkB,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW,EAAG,SAAQ;MACzD,iBAAiB,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW,EAAG,SAAQ;KACzD,EACA,OAAM,EACN,SAAQ;GACZ,EACA,OAAM;CACV,EACA,OAAM;AAEF,IAAM,2BAA2B,iBACrC,OAAO;EACN,QAAQ;EACR,kBAAkB,iBAAE,OAAM,EAAG,IAAG,EAAG,IAAI,EAAE,EAAE,IAAI,KAAM;CACtD,EACA,OAAM;AAEF,IAAM,4BAA4B,iBACtC,OAAO;EACN,UAAU;EACV,aAAa;EACb,WAAW;CACZ,EACA,OAAM;AAEF,IAAM,2BAA2B,iBACrC,OAAO;EACN,IAAI;EACJ,SAAS;EACT,kBAAkB;EAClB,QAAQ;EACR,OAAO,iBAAE,KAAK,CAAC,UAAU,YAAY,WAAW,SAAS,CAAC;EAC1D,WAAW;EACX,WAAW;EACX,YAAY,gBAAgB,SAAQ;EACpC,WAAW,gBAAgB,SAAQ;CACpC,EACA,OAAM,EACN,YAAY,CAAC,QAAQ,YAAW;AAC/B,MAAK,OAAO,UAAU,gBAAiB,OAAO,eAAe,SAAY;AACvE,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,YAAY;MACnB,SAAS;KACV;EACH;AACA,MAAK,OAAO,UAAU,eAAgB,OAAO,cAAc,SAAY;AACrE,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,WAAW;MAClB,SAAS;KACV;EACH;AACF,CAAC;AAEI,IAAM,+BAA+B,iBACzC,OAAO;EACN,SAAS,iBAAE,MAAM,wBAAwB,EAAE,IAAI,0BAA0B;EACzE,YAAY,wBAAwB,SAAQ;CAC7C,EACA,OAAM,EACN,YAAY,CAAC,MAAM,YAAW;AAC7B,0BAAwB,WAAW,KAAK,SAAS,KAAK,YAAY,OAAO;AAC3E,CAAC;AAEI,IAAM,wBAAwB,iBAClC,OAAO,EAAE,SAAS,eAAe,UAAU,eAAc,CAAE,EAC3D,OAAM;AAEF,IAAM,6BAA6B,iBACvC,OAAO;EACN,SAAS;EACT,WAAW;EACX,OAAO;CACR,EACA,OAAM,EACN,OAAO,CAAC,aAAa,SAAS,MAAM,OAAO,SAAS,SAAS;EAC5D,MAAM,CAAC,SAAS,IAAI;EACpB,OAAO;CACR;AAEI,IAAM,kCAAkC,iBAC5C,OAAO;EACN,SAAS;EACT,UAAU;EACV,eAAe;EACf,gBAAgB,2BAA2B,SAAQ;CACpD,EACA,OAAM,EACN,YAAY,CAAC,SAAS,YAAW;AAChC,6BACE,QAAQ,gBACR,QAAQ,SACR,QAAQ,UACR,QAAQ,eACR,SACA,CAAC,kBAAkB,KAAK,CAAC;AAE7B,CAAC;AAEI,IAAM,mCAAmC,iBAC7C,OAAO;EACN,SAAS;EACT,UAAU;CACX,EACA,OAAM;AAEF,IAAM,2BAA2B,iBACrC,OAAO;EACN,SAAS;EACT,UAAU;EACV,QAAQ;CACT,EACA,OAAM;AAOF,IAAM,8BAA8B,iBACxC,OAAO;EACN,OAAO;EACP,QAAQ,iBACL,OAAO;IACN,IAAI;IACJ,eAAe;IACf,gBAAgB,2BAA2B,SAAQ;GACpD,EACA,OAAM;CACV,EACA,OAAM,EACN,YAAY,CAAC,SAAS,YAAW;AAChC,MAAI,QAAQ,MAAM,aAAa,GAAG;AAChC,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,SAAS,UAAU;MAC1B,SAAS;KACV;EACH;AACA,MAAI,QAAQ,MAAM,cAAc,QAAQ,MAAM,WAAW;AACvD,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,SAAS,WAAW;MAC3B,SAAS;KACV;EACH;AACA,MAAI,QAAQ,OAAO,kBAAkB,QAAQ,MAAM,eAAe;AAChE,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,UAAU,eAAe;MAChC,SAAS;KACV;EACH;AACA,6BACE,QAAQ,OAAO,gBACf,QAAQ,MAAM,IACd,QAAQ,OAAO,IACf,QAAQ,OAAO,eACf,SACA,CAAC,UAAU,kBAAkB,KAAK,CAAC;AAEvC,CAAC;AAEI,IAAM,+BAA+B,iBACzC,OAAO;EACN,SAAS;EACT,UAAU;CACX,EACA,OAAM;AAIF,IAAM,+BAA+B,iBACzC,OAAO;EACN,SAAS,iBAAE,MAAM,wBAAwB,EAAE,IAAI,0BAA0B;EACzE,YAAY,wBAAwB,SAAQ;CAC7C,EACA,OAAM,EACN,YAAY,CAAC,MAAM,YAAW;AAC7B,0BAAwB,WAAW,KAAK,SAAS,KAAK,YAAY,OAAO;AAC3E,CAAC;AAEI,IAAM,kBAAkB,iBAAE,OAAO,EAAE,SAAS,cAAa,CAAE,EAAE,OAAM;AACnE,IAAM,wBAAwB,iBAClC,OAAO,EAAE,SAAS,eAAe,UAAU,eAAc,CAAE,EAC3D,OAAM;AACF,IAAM,yBAAyB,iBACnC,OAAO,EAAE,SAAS,eAAe,QAAQ,gBAAe,CAAE,EAC1D,OAAM;AAEF,IAAM,kCAAkC,iBAC5C,OAAO;EACN,uBAAuB;EACvB,gBAAgB,iBACb,OAAM,EACN,IAAI,yBAAyB,EAC7B,IAAI,yBAAyB;EAChC,QAAQ;;EAER,OAAO,2BAA2B,SAAQ;CAC3C,EACA,OAAM,EACN,OAAO,CAAC,UAAU,MAAM,OAAO,aAAa,MAAM,wBAAwB,GAAG;EAC5E,MAAM,CAAC,UAAU,UAAU;EAC3B,OAAO;CACR;AAEH,IAAM,4BAA4B,iBAC/B,OAAM,EACN,MAAM,uBAAuB,yCAAyC,EACtE,UAAU,CAAC,OAAO,YAAW;AAC5B,QAAM,SAAS,OAAO,KAAK;AAC3B,MAAI,CAAC,OAAO,cAAc,MAAM,GAAG;AACjC,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;KACV;AACD,WAAO,iBAAE;EACX;AACA,SAAO;AACT,CAAC;AAEH,IAAM,oCAAoC,iBACvC,OAAM,EACN,IAAG,EACH,IAAI,CAAC,EACL,IAAI,0BAA0B;AAE1B,IAAM,+BAA+B,iBACzC,OAAO;EACN,OAAO,kCAAkC,QAAQ,8BAA8B;EAC/E,QAAQ,wBAAwB,SAAQ;CACzC,EACA,OAAM;AAET,IAAM,kCAAkC,0BAA0B,KAChE,iCAAiC;AAG5B,IAAM,6BAA6B,iBACvC,OAAO;EACN,OAAO,gCAAgC,SAAQ;EAC/C,QAAQ,wBAAwB,SAAQ;CACzC,EACA,OAAM,EACN,UAAU,CAAC,UAAU,6BAA6B,MAAM,KAAK,CAAC;AAE1D,IAAM,+BAA+B,iBACzC,OAAO;EACN,SAAS;EACT,SAAS;EACT,QAAQ;EACR,cAAc;CACf,EACA,OAAM;AAEF,IAAM,4BAA4B,6BACtC,OAAO,EAAE,YAAY,0BAAyB,CAAE,EAChD,OAAM,EACN,OAAO,CAAC,SAAS,KAAK,aAAa,uBAAuB;EACzD,MAAM,CAAC,YAAY;EACnB,OAAO;CACR;AAEI,IAAM,oCAAoC,iBAC9C,OAAO;EACN,OAAO;EACP,OAAO;CACR,EACA,OAAM,EACN,YAAY,CAAC,SAAS,YAAW;AAChC,sCACE,QAAQ,OACR,QAAQ,MAAM,QACd,QAAQ,MAAM,gBACd,SACA,CAAC,OAAO,CAAC;AAEb,CAAC;AAEI,IAAM,kCAAkC,iBAC5C,OAAO;EACN,OAAO;EACP,UAAU;CACX,EACA,OAAM,EACN,YAAY,CAAC,SAAS,YAAW;AAChC,sCACE,QAAQ,OACR,QAAQ,SAAS,QACjB,QAAQ,SAAS,OAAO,gBACxB,SACA,CAAC,YAAY,QAAQ,CAAC;AAE1B,CAAC;AAII,IAAM,sBAAsB,iBAChC,OAAO;EACN,gBAAgB,0BAA0B,QAAQ,CAAC;EACnD,0BAA0B;EAC1B,OAAO,0BAA0B,QAAQ,GAAG;CAC7C,EACA,OAAM,EACN,UAAU,CAAC,WAAW;EACrB,gBAAgB,qBAAqB,MAAM,MAAM,cAAc;EAC/D,0BAA0B,oBAAoB,MAAM,MAAM,wBAAwB;EAClF,OAAO,MAAM;EACb,EACD,OAAO,CAAC,UAAU,MAAM,SAAS,KAAK,MAAM,SAAS,4BAA4B;EAChF,MAAM,CAAC,OAAO;EACd,OAAO;CACR;AAEI,IAAM,yBAAyB,iBAAE,MAAM;EAC5C;EACA;EACA;EACA;EACA;CACD;AAEM,IAAM,yBAAyB,iBACnC,OAAO;EACN,QAAQ;EACR,QAAQ,uBAAuB,SAAQ;CACxC,EACA,OAAM,EACN,YAAY,CAAC,QAAQ,YAAW;AAC/B,QAAM,EAAE,QAAQ,OAAM,IAAK;AAC3B,MAAI,OAAO,cAAc,SAAS;AAChC,QAAI,WAAW,MAAM;AACnB,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,QAAQ;QACf,SAAS;OACV;IACH;AACA;EACF;AACA,MACE,WAAW,QACX,kBAAkB,MAAM,MAAM,OAAO,WACrC,qBAAqB,MAAM,MAAM,OAAO,cACxC,aAAa,MAAM,MAAM,OAAO,YAChC,mBAAmB,MAAM,MAAM,OAAO,gBACtC;AACA,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,QAAQ;MACf,SAAS;KACV;AACD;EACF;AACA,MACE,OAAO,cAAc,gBACpB,CAAC,kBAAkB,MAAM,KAAK,OAAO,UAAU,YAChD;AACA,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,QAAQ;MACf,SAAS;KACV;EACH;AACA,OACG,OAAO,cAAc,YAAY,OAAO,cAAc,cACvD,CAAC,sBAAsB,MAAM,GAC7B;AACA,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,QAAQ;MACf,SAAS;KACV;EACH;AACF,CAAC;AAEI,IAAM,yBAAyB,iBACnC,OAAO;EACN,SAAS;EACT,qBAAqB;EACrB,SAAS,iBAAE,MAAM,sBAAsB,EAAE,IAAI,0BAA0B;EACvE,YAAY;EACZ,SAAS,iBAAE,QAAO;CACnB,EACA,OAAM,EACN,YAAY,CAAC,MAAM,YAAW;AAC7B,MACE,KAAK,WAAW,YAAY,KAAK,WACjC,KAAK,WAAW,6BAA6B,KAAK,qBAClD;AACA,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,YAAY;MACnB,SAAS;KACV;EACH;AACA,MAAI,KAAK,QAAQ,KAAK,CAAC,EAAE,OAAM,MAAO,OAAO,YAAY,KAAK,OAAO,GAAG;AACtE,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,SAAS;MAChB,SAAS;KACV;EACH;AACA,MAAI,KAAK,WAAW,KAAK,QAAQ,WAAW,GAAG;AAC7C,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,SAAS;MAChB,SAAS;KACV;EACH;AACF,CAAC;AAEI,IAAM,wBAAwB,iBAClC,OAAO;EACN,SAAS;EACT,qBAAqB,iBAClB,OAAM,EACN,IAAI,yBAAyB,EAC7B,IAAI,yBAAyB;EAChC,WAAW,iBAAE,MAAM,oBAAoB,EAAE,IAAI,CAAC,EAAE,IAAI,uBAAuB;CAC5E,EACA,OAAM,EACN,YAAY,CAAC,OAAO,YAAW;AAC9B,QAAM,OAAO,oBAAI,IAAG;AACpB,aAAW,CAAC,OAAO,QAAQ,KAAK,MAAM,UAAU,QAAO,GAAI;AACzD,QAAI,oBAAoB,QAAQ,MAAM,MAAM,SAAS;AACnD,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,aAAa,KAAK;QACzB,SAAS;OACV;IACH;AACA,QAAI,KAAK,IAAI,SAAS,cAAc,GAAG;AACrC,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,aAAa,OAAO,gBAAgB;QAC3C,SAAS;OACV;IACH;AACA,SAAK,IAAI,SAAS,cAAc;AAChC,UAAM,WACJ,SAAS,eAAe,UACpB,SAAS,wBACT,SAAS;AACf,UAAM,WACJ,SAAS,eAAe,UACpB,SAAS,OAAO,WAChB,SAAS,OAAO;AACtB,QAAI,cAAc,aAAa,OAAO,IAAI,WAAW,IAAI;AACvD,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,aAAa,OAAO,QAAQ;QACnC,SAAS;OACV;IACH;EACF;AACF,CAAC;AAEI,IAAM,+BAA+B,iBACzC,OAAO;EACN,QAAQ,iBAAE,QAAQ,UAAU;EAC5B,gBAAgB,iBACb,OAAM,EACN,IAAI,yBAAyB,EAC7B,IAAI,yBAAyB;EAChC,aAAa,iBAAE,KAAK,CAAC,aAAa,WAAW,CAAC;EAC9C,QAAQ;CACT,EACA,OAAM;AAEF,IAAM,kCAAkC,iBAC5C,OAAO;EACN,QAAQ,iBAAE,QAAQ,UAAU;EAC5B,gBAAgB,iBACb,OAAM,EACN,IAAI,yBAAyB,EAC7B,IAAI,yBAAyB;EAChC,iBAAiB,iBAAE,MAAM,CAAC,qBAAqB,oBAAoB,CAAC;EACpE,SAAS,uBAAuB,SAAQ;CACzC,EACA,OAAM;AAEF,IAAM,yBAAyB,iBACnC,OAAO;EACN,SAAS;EACT,qBAAqB;EACrB,qBAAqB,iBAClB,OAAM,EACN,IAAI,yBAAyB,EAC7B,IAAI,yBAAyB;EAChC,SAAS,iBACN,MACC,iBAAE,mBAAmB,UAAU;IAC7B;IACA;GACD,CAAC,EAEH,IAAI,CAAC,EACL,IAAI,uBAAuB;CAC/B,EACA,OAAM;AAMF,IAAM,4CACX,sBAAsB,YAAY,CAAC,OAAO,YAAW;AACnD,QAAM,YAAY,oBAAI,IAAG;AACzB,QAAM,UAAoB,CAAA;AAC1B,MAAI;AAIJ,aAAW,CAAC,OAAO,QAAQ,KAAK,MAAM,UAAU,QAAO,GAAI;AACzD,QAAI,SAAS,eAAe,WAAW,SAAS,eAAe,QAAQ;AACrE,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,aAAa,OAAO,YAAY;QACvC,SAAS;OACV;AACD;IACF;AACA,QACE,SAAS,2BAA2B,QACpC,SAAS,OAAO,iBAAiB,QACjC;AACA,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,aAAa,KAAK;QACzB,SAAS;OACV;IACH;AACA,QAAI,UAAU,IAAI,SAAS,OAAO,EAAE,GAAG;AACrC,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,aAAa,OAAO,UAAU,IAAI;QACzC,SAAS;OACV;IACH;AACA,cAAU,IAAI,SAAS,OAAO,EAAE;AAChC,QAAI,SAAS,eAAe,SAAS;AACnC,UAAI,kBAAkB,QAAW;AAC/B,gBAAQ,SAAS;UACf,MAAM;UACN,MAAM,CAAC,aAAa,KAAK;UACzB,SAAS;SACV;MACH;AACA,sBAAgB;IAClB,OAAO;AACL,cAAQ,KAAK,SAAS,OAAO,EAAE;IACjC;EACF;AAEA,MAAI,kBAAkB,QAAW;AAC/B,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,WAAW;MAClB,SAAS;KACV;AACD;EACF;AACA,MAAI,MAAM,UAAU,GAAG,EAAE,MAAM,eAAe;AAC5C,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,WAAW;MAClB,SAAS;KACV;EACH;AACA,aAAW,CAAC,OAAO,QAAQ,KAAK,MAAM,UAAU,QAAO,GAAI;AACzD,QACE,SAAS,eAAe,UACxB,SAAS,OAAO,YAAY,cAAc,OAAO,IACjD;AACA,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,aAAa,OAAO,UAAU,SAAS;QAC9C,SAAS;OACV;IACH;EACF;AACA,QAAM,gBAAgB,CAAC,GAAG,OAAO,EAAE,KAAI;AACvC,MAAI,QAAQ,KAAK,CAAC,QAAQ,UAAU,WAAW,cAAc,KAAK,CAAC,GAAG;AACpE,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,WAAW;MAClB,SAAS;KACV;EACH;AACF,CAAC;AAEI,IAAM,2CAA2C,iBACrD,OAAO;EACN,gBAAgB,iBACb,OAAM,EACN,IAAI,yBAAyB,EAC7B,IAAI,yBAAyB;EAChC,QAAQ;CACT,EACA,OAAM,EACN,YAAY,CAAC,QAAQ,YAAW;AAC/B,MACG,OAAO,OAAO,eAAe,WAAW,OAAO,OAAO,eAAe,UACtE,OAAO,OAAO,cAAc,UAC5B;AACA,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,QAAQ;MACf,SAAS;KACV;EACH;AACF,CAAC;AAEI,IAAM,6CAA6C,iBACvD,OAAO;EACN,SAAS;EACT,qBAAqB,iBAClB,OAAM,EACN,IAAI,yBAAyB,EAC7B,IAAI,yBAAyB;EAChC,qBAAqB;EACrB,SAAS,iBACN,MAAM,wCAAwC,EAC9C,IAAI,CAAC,EACL,IAAI,8BAA8B;CACtC,EACA,OAAM,EACN,YAAY,CAAC,UAAU,YAAW;AACjC,QAAM,UAAoB,CAAA;AAC1B,MAAI,aAAa;AACjB,aAAW,CAAC,OAAO,MAAM,KAAK,SAAS,QAAQ,QAAO,GAAI;AACxD,QAAI,OAAO,OAAO,YAAY,SAAS,SAAS;AAC9C,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,WAAW,OAAO,UAAU,SAAS;QAC5C,SAAS;OACV;IACH;AACA,QAAI,QAAQ,GAAG;AACb,YAAM,WAAW,SAAS,QAAQ,QAAQ,CAAC;AAC3C,UACE,aAAa,UACb,OAAO,OAAO,mBAAmB,SAAS,OAAO,iBAAiB,GAClE;AACA,gBAAQ,SAAS;UACf,MAAM;UACN,MAAM,CAAC,WAAW,OAAO,UAAU,gBAAgB;UACnD,SAAS;SACV;MACH;IACF;AACA,QAAI,OAAO,OAAO,eAAe;AAAS,oBAAc;AACxD,QAAI,OAAO,OAAO,eAAe;AAAQ,cAAQ,KAAK,OAAO,OAAO,QAAQ;EAC9E;AACA,MAAI,eAAe,KAAK,SAAS,QAAQ,GAAG,EAAE,GAAG,OAAO,eAAe,SAAS;AAC9E,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,SAAS;MAChB,SAAS;KACV;EACH;AACA,QAAM,gBAAgB,CAAC,GAAG,OAAO,EAAE,KAAI;AACvC,MAAI,QAAQ,KAAK,CAAC,QAAQ,UAAU,WAAW,cAAc,KAAK,CAAC,GAAG;AACpE,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,SAAS;MAChB,SAAS;KACV;EACH;AACF,CAAC;AA4CH,SAAS,2BACP,gBACA,SACA,UACA,eACA,SACA,MAAmB;AAEnB,MACE,mBAAmB,WAClB,eAAe,IAAI,YAAY,WAC9B,eAAe,IAAI,aAAa,YAChC,eAAe,IAAI,kBAAkB,gBACvC;AACA,YAAQ,SAAS;MACf,MAAM;MACN;MACA,SAAS;KACV;EACH;AACF;AAIA,SAAS,wBACP,UACA,MACA,YACA,SAA8B;AAE9B,QAAM,WAAW,KAAK,CAAC;AACvB,MAAI,aAAa,UAAa,KAAK,KAAK,CAAC,QAAQ,IAAI,YAAY,SAAS,OAAO,GAAG;AAClF,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,QAAQ;KAChB;EACH;AACA,MAAI,eAAe;AAAM;AAEzB,QAAM,WAAW,KAAK,GAAG,EAAE;AAC3B,MAAI,aAAa,QAAW;AAC1B,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,YAAY;KACpB;AACD;EACF;AAEA,MAAI;AACJ,MAAI;AACF,oBAAgB,wBAAwB,UAAU;EACpD,QAAQ;AACN,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,YAAY;KACpB;AACD;EACF;AACA,MACE,cAAc,aAAa,YAC3B,cAAc,YAAY,SAAS,WACnC,cAAc,cAAc,SAAS,aACrC,cAAc,OAAO,SAAS,IAC9B;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,YAAY;KACpB;EACH;AACF;AAEA,SAAS,oCACP,OACA,QAGA,gBACA,SACA,MAAmB;AAEnB,QAAM,SAAS,MAAM;AACrB,QAAM,eAAe,QAAQ,SAAS,OAAO,KAAK,OAAO;AACzD,QAAM,cACJ,QAAQ,SACJ,CAAC,OAAO,qBAAqB,YAAY,OAAO,kBAAkB,UAAU,IAC5E,CAAC,OAAO,UAAU;AACxB,MACE,OAAO,YAAY,OAAO,OAAO,WACjC,OAAO,YAAY,OAAO,OAAO,WACjC,OAAO,WAAW,OAAO,OAAO,UAChC,iBAAiB,OAAO,OAAO,gBAC/B,OAAO,kBAAkB,OAAO,OAAO,iBACvC,YAAY,KAAK,CAAC,eAAe,eAAe,OAAO,OAAO,UAAU,KACxE,mBAAmB,OAAO,gBAC1B;AACA,YAAQ,SAAS;MACf,MAAM;MACN;MACA,SAAS;KACV;EACH;AACF;AAEA,SAAS,kBACP,QAAwB;AAExB,SAAO,WAAW;AACpB;AAEA,SAAS,sBAAsB,QAAwB;AACrD,SACE,CAAC,kBAAkB,MAAM,MACxB,EAAE,kBAAkB,WAAW,OAAO,iBAAiB;AAE5D;AAEA,SAAS,kBAAkB,QAAwB;AACjD,SAAO,aAAa,SAAS,OAAO,UAAU,OAAO;AACvD;AAEA,SAAS,aAAa,QAAwB;AAC5C,SAAO,kBAAkB,MAAM,IAAI,OAAO,WAAW,OAAO;AAC9D;AAEA,SAAS,qBACP,QAAwB;AAExB,MAAI,kBAAkB,MAAM;AAAG,WAAO,OAAO;AAC7C,MAAI,cAAc;AAAQ,WAAO;AACjC,MAAI,YAAY;AAAQ,WAAO;AAC/B,MAAI,aAAa;AAAQ,WAAO;AAChC,SAAO;AACT;AAEA,SAAS,mBAAmB,QAAwB;AAClD,MAAI,kBAAkB,MAAM;AAAG,WAAO,OAAO;AAC7C,SAAO,cAAc,SAAS,OAAO,WAAW,OAAO;AACzD;AAEA,SAAS,oBACP,UAA8C;AAE9C,SAAO,SAAS,eAAe,UAAU,SAAS,OAAO,KAAK,SAAS,OAAO;AAChF;;;ACl/BO,IAAM,4BAA4B,iBACtC,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,QAAQ,iBAAE,KAAK,CAAC,UAAU,QAAQ,CAAC;EACnC,QAAQ;EACR,UAAU,iBAAE,KAAK,CAAC,gBAAgB,cAAc,gBAAgB,YAAY,CAAC;EAC7E,gBAAgB,iBAAE,KAAK,CAAC,UAAU,SAAS,CAAC;EAC5C,YAAY;EACZ,eAAe;EACf,YAAY;CACb,EACA,OAAM;AASF,IAAM,wBAAwB,iBAAE,KAAK;EAC1C;EACA;EACA;EACA;EACA;CACD;AAGM,IAAM,yBAAyB,iBAAE,KAAK;EAC3C;EACA;EACA;EACA;CACD;AAGM,IAAM,wBAAwB,iBAAE,KAAK;EAC1C;EACA;EACA;EACA;CACD;AAED,IAAM,wBAAwB,EAAE,KAAK,GAAG,KAAK,IAAG;AAChD,IAAM,6BAA6B,EAAE,KAAK,GAAG,KAAK,IAAG;AAS9C,IAAM,6BAA6B,iBACvC,OAAM,EACN,IAAI,sBAAsB,GAAG,EAC7B,IAAI,sBAAsB,GAAG,EAC7B,MAAM,mCAAmC;EACxC,SAAS;CACV;AAGI,IAAM,0BAA0B,iBACpC,OAAM,EACN,IAAI,2BAA2B,GAAG,EAClC,IAAI,2BAA2B,GAAG,EAClC,MAAM,mCAAmC;EACxC,SAAS;CACV;AAOI,IAAM,wBAAwB,iBAClC,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,SAAS;EACT,YAAY;EACZ,QAAQ;EACR,SAAS;EACT,YAAY;EACZ,YAAY,iBAAiB,SAAQ;EACrC,OAAO,sBAAsB,SAAQ;EACrC,UAAU,eAAe,SAAQ;EACjC,gBAAgB,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW,EAAG,SAAQ;CACxD,EACA,OAAM;;;ACxEF,IAAM,6BAA6B;AACnC,IAAM,6BAA6B,KAAK,OAAO,OAAO;AAE7D,IAAM,6BAA6B,gBAChC,OAAO,EAAE,EACT,OAAO,CAAC,UAAU,OAAO,KAAK,OAAO,WAAW,EAAE,eAAe,IAAI;EACpE,OAAO;CACR;AAEI,IAAM,iCACX,2BAA2B,MAAK;AAC3B,IAAM,gCACX,2BAA2B,MAAK;AAElC,IAAM,6BAA6B,iBAChC,OAAO;EACN,WAAW,iBAAE,QAAQ,yBAAyB;EAC9C,MAAM;CACP,EACA,OAAM;AAEF,IAAM,8BAA8B,iBACxC,OAAO;EACN,MAAM,iBAAE,QAAQ,QAAQ;EACxB,QAAQ,iBAAE,QAAQ,yBAAyB;EAC3C,SAAS,iBAAE,QAAQ,CAAC;EACpB,SAAS;EACT,eAAe;EACf,WAAW;EACX,gBAAgB;CACjB,EACA,OAAM;AAEF,IAAM,6BAA6B,iBAAE,mBAAmB,QAAQ;EACrE,iBAAE,OAAO,EAAE,MAAM,iBAAE,QAAQ,OAAO,GAAG,QAAQ,kBAAiB,CAAE,EAAE,OAAM;EACxE,iBAAE,OAAO,EAAE,MAAM,iBAAE,QAAQ,OAAO,GAAG,QAAQ,2BAA0B,CAAE,EAAE,OAAM;EACjF,iBAAE,OAAO,EAAE,MAAM,iBAAE,QAAQ,MAAM,GAAG,QAAQ,0BAAyB,CAAE,EAAE,OAAM;EAC/E,iBACG,OAAO,EAAE,MAAM,iBAAE,QAAQ,YAAY,GAAG,QAAQ,gCAA+B,CAAE,EACjF,OAAM;EACT,iBACG,OAAO;IACN,MAAM,iBAAE,QAAQ,mBAAmB;IACnC,QAAQ;GACT,EACA,OAAM;EACT,iBACG,OAAO;IACN,MAAM,iBAAE,QAAQ,kBAAkB;IAClC,QAAQ;GACT,EACA,OAAM;EACT,iBAAE,OAAO,EAAE,MAAM,iBAAE,QAAQ,OAAO,GAAG,QAAQ,2BAA0B,CAAE,EAAE,OAAM;EACjF,iBACG,OAAO,EAAE,MAAM,iBAAE,QAAQ,SAAS,GAAG,QAAQ,6BAA4B,CAAE,EAC3E,OAAM;EACT,iBACG,OAAO;IACN,MAAM,iBAAE,QAAQ,uBAAuB;IACvC,YAAY,iBAAE,KAAK,CAAC,SAAS,QAAQ,YAAY,CAAC;IAClD,QAAQ,iBAAE,MAAM;MACd;MACA;MACA;KACD;GACF,EACA,OAAM,EACN,YAAY,CAAC,OAAO,YAAW;AAC9B,UAAM,aACJ,YAAY,MAAM,SACd,eACA,aAAa,MAAM,SACjB,SACA;AACR,QAAI,MAAM,eAAe,YAAY;AACnC,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,YAAY;QACnB,SAAS;OACV;IACH;AACA,QAAI,MAAM,OAAO,iBAAiB,QAAW;AAC3C,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,UAAU,cAAc;QAC/B,SAAS;OACV;IACH;EACF,CAAC;EACH,iBAAE,OAAO,EAAE,MAAM,iBAAE,QAAQ,WAAW,GAAG,QAAQ,sBAAqB,CAAE,EAAE,OAAM;CACjF;AAEM,IAAM,8BAA8B,iBACxC,OAAO;EACN,MAAM,iBAAE,QAAQ,QAAQ;EACxB,SAAS,iBAAE,QAAQ,CAAC;EACpB,aAAa,iBAAE,OAAM,EAAG,IAAG,EAAG,SAAQ,EAAG,IAAI,GAAU;EACvD,kBAAkB;EAClB,mBAAmB;CACpB,EACA,OAAM;AAkBT,IAAM,0BAA0B,iBAC7B,OAAM,EACN,IAAG,EACH,SAAQ,EACR,IAAI,0BAA0B;AACjC,IAAM,uBAAuB,iBAC1B,OAAM,EACN,IAAG,EACH,YAAW,EACX,IAAI,0BAA0B;AAE1B,IAAM,2BAA2B,iBACrC,OAAO;EACN,QAAQ;EACR,kBAAkB;EAClB,aAAa;EACb,kBAAkB;EAClB,wBAAwB;CACzB,EACA,OAAM;AAET,IAAM,4BAA4B,iBAC/B,OAAO;EACN,IAAI;EACJ,MAAM,iBAAE,KAAK,CAAC,gBAAgB,cAAc,cAAc,CAAC;EAC3D,YAAY;CACb,EACA,OAAM;AAET,IAAM,8BAA8B,iBACjC,OAAO;EACN,QAAQ,iBAAE,QAAQ,CAAC;EACnB,QAAQ;EACR,OAAO;EACP,aAAa;EACb,mBAAmB;EACnB,kBAAkB;EAClB,uBAAuB,iBACpB,OAAO;IACN,QAAQ;IACR,OAAO;IACP,aAAa;GACd,EACA,OAAM;EACT,YAAY;EACZ,WAAW;EACX,QAAQ;CACT,EACA,OAAM;AAEF,IAAM,0CAA0C,iBACpD,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,OAAO,iBAAE,QAAQ,kBAAkB;EACnC,SAAS;EACT,eAAe;EACf,kBAAkB;EAClB,kBAAkB;EAClB,wBAAwB;EACxB,aAAa;EACb,cAAc;EACd,UAAU;CACX,EACA,OAAM,EACN,YAAY,CAAC,SAAS,YAAW;AAChC,QAAM,eAAe,QAAQ,SAAS;AACtC,QAAM,mBACJ,aAAa,SAAS,aAAa,QAAQ,aAAa;AAC1D,QAAM,gBACJ,QAAQ,SAAS,SACjB,QAAQ,SAAS,SACjB,QAAQ,SAAS,QACjB,QAAQ,SAAS,cACjB,QAAQ,SAAS,oBACjB,QAAQ,SAAS,mBACjB,mBACA,QAAQ,SAAS,aACjB,QAAQ,SAAS,YACjB,QAAQ,SAAS;AAEnB,MAAI,kBAAkB,QAAQ,aAAa;AACzC,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,aAAa;MACpB,SAAS;KACV;EACH;AACA,MAAI,QAAQ,SAAS,sBAAsB,QAAQ,SAAS,aAAa;AACvE,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,YAAY,mBAAmB;MACtC,SAAS;KACV;EACH;AACA,MAAI,QAAQ,SAAS,mBAAmB,QAAQ,SAAS,aAAa;AACpE,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,YAAY,kBAAkB;MACrC,SAAS;KACV;EACH;AACA,MAAI,QAAQ,SAAS,aAAa,kBAAkB;AAClD,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,YAAY,YAAY;MAC/B,SAAS;KACV;EACH;AACF,CAAC;AAEH,IAAM,8BAA8B,iBAAE,OAAO;EAC3C,iBAAiB,iBAAE,QAAQ,CAAC;EAC5B,kBAAkB;EAClB,cAAc,iBAAE,OAAM,EAAG,IAAG,EAAG,SAAQ,EAAG,IAAI,0BAA0B;EACxE,gBAAgB;EAChB,aAAa,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW,EAAG,IAAI,0BAA0B;EAC1E,eAAe;EACf,WAAW;EACX,WAAW;CACZ;AAED,IAAM,6BAA6B,4BAChC,OAAO;EACN,OAAO,iBAAE,QAAQ,SAAS;EAC1B,SAAS,cAAc,SAAQ;CAChC,EACA,OAAM;AAET,IAAM,4BAA4B,4BAC/B,OAAO;EACN,OAAO,iBAAE,QAAQ,QAAQ;EACzB,SAAS;EACT,SAAS;EACT,UAAU;CACX,EACA,OAAM;AAET,IAAM,+BAA+B,4BAClC,OAAO;EACN,OAAO,iBAAE,QAAQ,WAAW;EAC5B,SAAS;EACT,SAAS;EACT,UAAU;EACV,aAAa;CACd,EACA,OAAM;AAET,IAAM,+BAA+B,iBAClC,OAAO;EACN,OAAO,iBAAE,QAAQ,WAAW;EAC5B,iBAAiB,iBAAE,QAAQ,CAAC;EAC5B,kBAAkB;EAClB,SAAS;EACT,aAAa;CACd,EACA,OAAM;AAET,IAAM,6BAA6B,iBAChC,OAAO;EACN,OAAO,iBAAE,QAAQ,SAAS;EAC1B,iBAAiB,iBAAE,QAAQ,CAAC;EAC5B,kBAAkB;EAClB,WAAW;CACZ,EACA,OAAM;AAEF,IAAM,4BAA4B,iBACtC,mBAAmB,SAAS;EAC3B;EACA;EACA;EACA;EACA;CACD,EACA,YAAY,CAAC,QAAQ,YAAW;AAC/B,MAAI,iBAAiB,UAAU,OAAO,cAAc,OAAO,cAAc;AACvE,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,aAAa;MACpB,SAAS;KACV;EACH;AACA,MAAI,mBAAmB,UAAU,OAAO,gBAAgB,OAAO,gBAAgB;AAC7E,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,eAAe;MACtB,SAAS;KACV;EACH;AACA,MAAI,mBAAmB,QAAQ;AAC7B,UAAM,mBAAmB,OAAO,gBAAgB;AAChD,UAAM,iBAAiB,OAAO,cAAc;AAC5C,QAAI,qBAAqB,gBAAgB;AACvC,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,eAAe;QACtB,SAAS;OACV;IACH;AACA,QACE,OAAO,UAAU,aAChB,OAAO,YAAY,WAAe,kBACnC;AACA,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,SAAS;QAChB,SAAS;OACV;IACH;EACF;AACA,MAAI,OAAO,UAAU,aAAa,OAAO,UAAU;AAAW;AAE9D,MAAI,OAAO,qBAAqB,OAAO,QAAQ,kBAAkB;AAC/D,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,kBAAkB;MACzB,SAAS;KACV;EACH;AACA,MAAI,OAAO,UAAU;AAAa;AAElC,MAAI,OAAO,YAAY,OAAO,QAAQ,OAAO,SAAS;AACpD,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,SAAS;MAChB,SAAS;KACV;EACH;AACA,MACE,OAAO,kBAAkB,OAAO,QAAQ,eACxC,OAAO,QAAQ,cAAc,OAAO,gBACpC;AACA,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,eAAe;MACtB,SAAS;KACV;EACH;AACF,CAAC;;;ACrXI,IAAM,iBAAiB,OAAO,OAAO;EAC1C,IAAI;EACJ,qBAAqB;EACrB,YAAY;EACZ,sBAAsB;EACtB,mBAAmB;EACnB,qBAAqB;EACrB,cAAc;EACd,sBAAsB;EACtB,kBAAkB;EAClB,0BAA0B;EAC1B,sBAAsB;CACd;AAIH,IAAM,kBAAkB;EAC7B;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAGK,IAAM,qBAAqB,iBAAE,KAAK,eAAe;AAIxD,IAAM,uBAA+D,OAAO,OAAO;EACjF,IAAI,eAAe;EACnB,sBAAsB,eAAe;EACrC,aAAa,eAAe;EAC5B,uBAAuB,eAAe;EACtC,oBAAoB,eAAe;EACnC,sBAAsB,eAAe;EACrC,eAAe,eAAe;EAC9B,uBAAuB,eAAe;EACtC,mBAAmB,eAAe;EAClC,4BAA4B,eAAe;EAC3C,uBAAuB,eAAe;CACvC;AAGK,SAAU,oBAAoB,MAAkB;AACpD,SAAO,qBAAqB,IAAI;AAClC;AAEO,IAAM,yBAAyB,iBACnC,OAAO;EACN,OAAO,iBACJ,OAAO;IACN,MAAM;IACN,UAAU,iBAAE,OAAM,EAAG,IAAG,EAAG,IAAI,CAAC,EAAE,IAAI,GAAG;IACzC,SAAS,iBAAE,OAAM,EAAG,IAAI,CAAC,EAAE,IAAI,IAAI;GACpC,EACA,OAAM;CACV,EACA,OAAM;;;ACjDF,IAAM,4BAA4B;AAClC,IAAM,iCAAiC;AACvC,IAAM,qCAAqC;AAC3C,IAAM,8BAA8B;AACpC,IAAM,sBAAsB;AAE5B,IAAM,yBAAyB,iBACnC,OAAM,EACN,IAAG,EACH,YAAW,EACX,IAAI,OAAO,gBAAgB,EAC3B,MAAK;AAER,IAAM,+BAA+B,iBAAE,MAAM;EAC3C;EACA;EACA;CACD;AAEM,IAAM,+BAA+B,iBACzC,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,YAAY;EACZ,YAAY,iBAAE,KAAK;IACjB;IACA;IACA;GACD;EACD,UAAU;EACV,SAAS,iBAAE,KAAK,CAAC,WAAW,iBAAiB,YAAY,CAAC;EAC1D,eAAe;EACf,YAAY;EACZ,UAAU;EACV,SAAS,cAAc,SAAQ;EAC/B,gBAAgB;CACjB,EACA,OAAM,EACN,YAAY,CAAC,gBAAgB,YAAW;AACvC,QAAM,kBACH,eAAe,eAAe,uBAC5B,eAAe,YAAY,aAC1B,eAAe,aAAa,eAAe,cAC3C,eAAe,YAAY,WAC9B,eAAe,eAAe,4BAC5B,eAAe,YAAY,mBAC1B,CAAC,gBAAgB,UAAU,eAAe,QAAQ,EAAE,WACpD,eAAe,YAAY,WAC9B,eAAe,eAAe,yBAC5B,eAAe,YAAY,gBAC1B,CAAC,cAAc,UAAU,eAAe,QAAQ,EAAE,WAClD,eAAe,YAAY,UAC3B,eAAe,aAAa,eAAe;AAEjD,MAAI,iBAAiB;AACnB,YAAQ,SAAS;MACf,MAAM;MACN,SACE;KACH;EACH;AACF,CAAC;AAEI,IAAM,6BAA6B,iBACvC,OAAO;EACN,SAAS;EACT,WAAW,iBAAE,QAAQ,yBAAyB;EAC9C,OAAO;EACP,YAAY;EACZ,mBAAmB;EACnB,KAAK;EACL,YAAY;CACb,EACA,OAAM,EACN,YAAY,CAAC,UAAU,YAAW;AACjC,MAAI,SAAS,MAAM,WAAW,4BAA4B;AACxD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,OAAO;KACf;EACH;AACA,MAAI,SAAS,kBAAkB,WAAW,yCAAyC;AACjF,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,mBAAmB;KAC3B;EACH;AACA,MAAI,SAAS,eAAe,SAAS,IAAI,YAAY;AACnD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,YAAY;KACpB;EACH;AACF,CAAC;AAEH,IAAM,6BAA6B,iBAChC,OAAO;EACN,IAAI;EACJ,OAAO,iBAAE,OAAM,EAAG,KAAI,EAAG,IAAI,CAAC,EAAE,IAAI,GAAG;EACvC,WAAW;CACZ,EACA,OAAM;AAEF,IAAM,+BAA+B,iBACzC,OAAO;EACN,OAAO,iBAAE,OAAM,EAAG,KAAI,EAAG,IAAI,CAAC,EAAE,IAAI,GAAG;EACvC,QAAQ,iBAAE,MAAM,0BAA0B,EAAE,IAAI,mBAAmB;CACpE,EACA,OAAM,EACN,YAAY,CAAC,SAAS,YAAW;AAChC,QAAM,WAAW,oBAAI,IAAG;AACxB,aAAW,CAAC,OAAO,KAAK,KAAK,QAAQ,OAAO,QAAO,GAAI;AACrD,QAAI,SAAS,IAAI,MAAM,EAAE,GAAG;AAC1B,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,UAAU,OAAO,IAAI;QAC5B,SAAS;OACV;IACH;AACA,aAAS,IAAI,MAAM,EAAE;EACvB;AACF,CAAC;AAEH,IAAM,sCAAsC,iBACzC,OAAO;EACN,WAAW,iBAAE,QAAQ,aAAa;EAClC,SAAS,iBAAE,QAAQ,CAAC;EACpB,MAAM,gBAAgB,OAAO,EAAE;EAC/B,SAAS,iBAAE,QAAQ,8BAA8B;EACjD,cAAc,iBAAE,QAAQ,EAAE;CAC3B,EACA,OAAM;AAET,IAAM,sCAAsC,iBACzC,OAAO;EACN,WAAW,iBAAE,QAAQ,aAAa;EAClC,SAAS,iBAAE,QAAQ,CAAC;EACpB,MAAM,gBAAgB,OAAO,EAAE;EAC/B,SAAS,iBAAE,QAAQ,kCAAkC;EACrD,cAAc,iBAAE,QAAQ,EAAE;CAC3B,EACA,OAAM;AAET,IAAM,4BAA4B,iBAAE,OAAO;EACzC,aAAa;EACb,IAAI;EACJ,OAAO,iBAAE,KAAK,CAAC,UAAU,SAAS,CAAC;EACnC,YAAY;EACZ,qBAAqB;EACrB,WAAW;EACX,WAAW,gBAAgB,SAAQ;CACpC;AAEM,IAAM,gCAAgC,0BAC1C,OAAO;EACN,MAAM,iBAAE,QAAQ,cAAc;EAC9B,OAAO,iBAAE,QAAQ,QAAQ;EACzB,YAAY;CACb,EACA,OAAM,EACN,YAAY,CAAC,MAAM,YAAW;AAC7B,MAAI,KAAK,cAAc,QAAW;AAChC,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,WAAW;MAClB,SACE;KACH;EACH;AACA,kCAAgC,MAAM,OAAO;AAC/C,CAAC;AAEI,IAAM,6BAA6B,0BACvC,OAAO;EACN,MAAM,iBAAE,QAAQ,cAAc;EAC9B,YAAY;CACb,EACA,OAAM,EACN,YAAY,CAAC,MAAM,YAAW;AAC7B,MAAI,KAAK,UAAU,aAAa,KAAK,cAAc,QAAW;AAC5D,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,WAAW;MAClB,SAAS;KACV;EACH;AACA,MAAI,KAAK,UAAU,YAAY,KAAK,cAAc,QAAW;AAC3D,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,WAAW;MAClB,SAAS;KACV;EACH;AACA,kCAAgC,MAAM,OAAO;AAC/C,CAAC;AAEI,IAAM,kCAAkC,iBAC5C,OAAO;EACN,QAAQ,iBAAE,QAAQ,yBAAyB;EAC3C,SAAS,iBAAE,QAAQ,kCAAkC;EACrD,IAAI;EACJ,eAAe;EACf,sBAAsB;EACtB,mBAAmB;EACnB,SAAS;EACT,eAAe,iBAAE,MAAM,0BAA0B,EAAE,IAAI,2BAA2B;EAClF,UAAU;EACV,kBAAkB;EAClB,uBAAuB;EACvB,WAAW;EACX,WAAW;CACZ,EACA,OAAM,EACN,YAAY,CAAC,UAAU,YAAW;AACjC,MAAI,SAAS,QAAQ,eAAe,SAAS,mBAAmB;AAC9D,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,WAAW,YAAY;MAC9B,SACE;KACH;EACH;AACA,MAAI,SAAS,QAAQ,oBAAoB,IAAI,eAAe,SAAS,IAAI;AACvE,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,WAAW,uBAAuB,OAAO,YAAY;MAC5D,SAAS;KACV;EACH;AAEA,QAAM,aAAa,oBAAI,IAAY,CAAC,SAAS,QAAQ,EAAE,CAAC;AACxD,aAAW,CAAC,OAAO,IAAI,KAAK,SAAS,cAAc,QAAO,GAAI;AAC5D,QAAI,WAAW,IAAI,KAAK,EAAE,GAAG;AAC3B,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,iBAAiB,OAAO,IAAI;QACnC,SAAS;OACV;IACH;AACA,eAAW,IAAI,KAAK,EAAE;AACtB,QAAI,KAAK,eAAe,SAAS,mBAAmB;AAClD,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,iBAAiB,OAAO,YAAY;QAC3C,SAAS;OACV;IACH;AACA,QAAI,KAAK,oBAAoB,IAAI,eAAe,SAAS,IAAI;AAC3D,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,iBAAiB,OAAO,uBAAuB,OAAO,YAAY;QACzE,SAAS;OACV;IACH;EACF;AAEA,QAAM,UAAU,SAAS;AACzB,MACE,QAAQ,IAAI,eAAe,SAAS,MACpC,QAAQ,IAAI,kBAAkB,SAAS,iBACvC,QAAQ,IAAI,eAAe,SAAS,qBACpC,QAAQ,IAAI,aAAa,SAAS,YAClC,QAAQ,IAAI,mBAAmB,SAAS,uBACxC;AACA,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,oBAAoB,KAAK;MAChC,SAAS;KACV;EACH;AACF,CAAC;AAEI,IAAM,8BAA8B,iBACxC,OAAO;EACN,YAAY;EACZ,IAAI;EACJ,eAAe;EACf,sBAAsB;EACtB,mBAAmB;EACnB,kBAAkB;EAClB,UAAU;EACV,kBAAkB;EAClB,kBAAkB;EAClB,uBAAuB;EACvB,WAAW;EACX,WAAW;CACZ,EACA,OAAM,EACN,YAAY,CAAC,OAAO,YAAW;AAC9B,QAAM,cAAc,MAAM;AAC1B,MACE,YAAY,IAAI,eAAe,MAAM,cACrC,YAAY,IAAI,YAAY,MAAM,MAClC,YAAY,IAAI,kBAAkB,MAAM,iBACxC,YAAY,IAAI,eAAe,MAAM,qBACrC,YAAY,IAAI,aAAa,MAAM,kBACnC;AACA,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,oBAAoB,KAAK;MAChC,SAAS;KACV;EACH;AACA,QAAM,UAAU,MAAM;AACtB,MACE,QAAQ,IAAI,YAAY,MAAM,MAC9B,CAAC,gCAAgC,QAAQ,GAAG,KAC5C,QAAQ,IAAI,aAAa,MAAM,MAC/B,QAAQ,IAAI,kBAAkB,MAAM,iBACpC,QAAQ,IAAI,eAAe,MAAM,qBACjC,QAAQ,IAAI,aAAa,MAAM,YAC/B,QAAQ,IAAI,mBAAmB,MAAM,uBACrC;AACA,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,oBAAoB,KAAK;MAChC,SAAS;KACV;EACH;AACF,CAAC;AAEH,SAAS,gCACP,OAAwD;AAExD,SACE,MAAM,eAAe,uBAAuB,MAAM,YAAY;AAElE;AAEO,IAAM,8BAA8B,iBACxC,OAAO;EACN,QAAQ,iBAAE,QAAQ,8BAA8B;EAChD,SAAS,iBAAE,QAAQ,kCAAkC;EACrD,UAAU;EACV,QAAQ,iBAAE,OAAO,eAAe,2BAA2B;CAC5D,EACA,OAAM,EACN,YAAY,CAAC,WAAW,YAAW;AAClC,QAAM,UAAU,OAAO,QAAQ,UAAU,MAAM;AAC/C,MAAI,QAAQ,SAAS,qBAAqB;AACxC,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,QAAQ;MACf,SAAS;KACV;EACH;AACA,aAAW,CAAC,SAAS,KAAK,KAAK,SAAS;AACtC,QAAI,YAAY,MAAM,IAAI;AACxB,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,UAAU,OAAO;QACxB,SAAS;OACV;IACH;AACA,QAAI,MAAM,eAAe,UAAU,SAAS,IAAI;AAC9C,cAAQ,SAAS;QACf,MAAM;QACN,MAAM,CAAC,UAAU,SAAS,YAAY;QACtC,SAAS;OACV;IACH;EACF;AACF,CAAC;AAEH,SAAS,gCACP,MAKA,SAA8B;AAE9B,QAAM,WAAW,KAAK;AACtB,MAAI,SAAS,IAAI,aAAa,KAAK,IAAI;AACrC,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,uBAAuB,OAAO,UAAU;MAC/C,SAAS;KACV;EACH;AACA,MAAI,SAAS,eAAe,KAAK,YAAY;AAC3C,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,uBAAuB,YAAY;MAC1C,SAAS;KACV;EACH;AACF;;;ACrZO,IAAM,2BAA2B,iBACrC,WAAW,UAAU,EACrB,OAAO,CAAC,UAAU,MAAM,eAAe,IAAI;EAC1C,OAAO;CACR,EACA,MAAK;AAED,IAAM,wBAAwB,iBAClC,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,SAAS;EACT,UAAU;EACV,WAAW;CACZ,EACA,OAAM;AAGF,IAAM,gCAAgC,iBAC1C,WAAW,UAAU,EACrB,OAAO,CAAC,UAAU,MAAM,eAAe,IAAI;EAC1C,OAAO;CACR,EACA,MAAK;AAGD,IAAM,iCAAiC,iBAC3C,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,SAAS;EACT,UAAU;EACV,SAAS,iBAAE,QAAQ,aAAa;CACjC,EACA,OAAM;;;ACrBF,IAAM,iCAAiC;AACvC,IAAM,yBAAyB;AAE/B,IAAM,sBAAsB;AAC5B,IAAM,oBAAoB;AAC1B,IAAM,2BAA2B;AACjC,IAAM,uBAAuB;AAC7B,IAAM,2BAA2B;AACjC,IAAM,8BAA8B;AACpC,IAAM,qBAAqB;AAC3B,IAAM,4BAA4B;AAClC,IAAM,0BAA0B;AAChC,IAAM,2BAA2B;AACjC,IAAM,yBAAyB;AAC/B,IAAM,yBAAyB,KAAK,KAAK,KAAK,KAAK;AACnD,IAAM,gCAAgC,MAAM;AAEnD,IAAM,iCAAiC,oBAAI,IAAI;EAC7C;EACA;EACA;CACD;AAGM,IAAM,4BAA4B,iBACtC,OAAM,EACN,IAAI,CAAC,EACL,IAAI,8BAA8B,EAGlC,OAAO,CAAC,UAAU,CAAC,yBAAyB,KAAK,KAAK,GAAG;EACxD,SAAS;CACV,EACA,OAAO,CAAC,UAAU,MAAM,KAAI,MAAO,OAAO;EACzC,SAAS;CACV,EACA,OAAO,CAAC,UAAU,CAAC,+BAA+B,IAAI,KAAK,GAAG;EAC7D,SAAS;CACV;AAGI,IAAM,wBAAwB,iBAClC,OAAM,EACN,IAAI,CAAC,EACL,IAAI,EAAE,EACN,MAAM,iCAAiC,0BAA0B;AAE7D,IAAM,2CACX;AAGK,IAAM,gCAAgC,iBAC1C,OAAM,EACN,MACC,IAAI,OAAO,wCAAwC,GACnD,mCAAmC;AAQhC,IAAM,oBAAoB,iBAC9B,OAAM,EACN,IAAI,CAAC,EACL,IAAI,GAAG,EACP,MACC,kCACA,6CAA6C;AAI1C,IAAM,qBAAqB,iBAC/B,OAAM,EACN,IAAI,CAAC,EACL,IAAI,EAAE,EACN,MAAM,mCAAmC,uBAAuB;AAEnE,IAAM,gBAAgB,IAAI,OAAO,wBAAwB;AAGlD,IAAM,yBAAyB,iBACnC,OAAM,EACN,IAAI,CAAC,EACL,IAAI,GAAG,EACP,MAAM,eAAe,8BAA8B;AAG/C,IAAM,wBAAwB,iBAClC,OAAM,EACN,MAAM,mBAAmB,wCAAwC;AAE7D,IAAM,0BAA0B;AAEvC,IAAM,kBAAkB,IAAI,OAAO,uBAAuB;AAGnD,IAAM,iBAAiB,iBAAE,OAAM,EAAG,MAAM,iBAAiB,kBAAkB;AAO5E,SAAU,kBAAkB,OAAa;AAC7C,MAAI,CAAC,gBAAgB,KAAK,KAAK;AAAG,WAAO;AACzC,QAAM,QAAQ,gBAAgB,KAAK,KAAK;AACxC,QAAM,aAAa,QAAQ,CAAC;AAC5B,QAAM,OAAO,QAAQ,CAAC;AACtB,MAAI,eAAe,UAAa,SAAS;AAAW,WAAO;AAC3D,QAAM,SAAS,OAAO,UAAU;AAChC,MAAI,CAAC,OAAO,cAAc,MAAM,KAAK,UAAU;AAAG,WAAO;AACzD,QAAM,aAAa,iBAAiB,IAAI;AACxC,MAAI,eAAe;AAAW,WAAO;AACrC,QAAM,UAAU,SAAS;AACzB,SAAO,WAAW,yBAAyB,UAAU;AACvD;AAEA,IAAM,mBAAqD,OAAO,OAAO;EACvE,GAAG;EACH,GAAG;EACH,GAAG;EACH,GAAG;CACJ;AAMM,IAAM,gCAAgC,iBAAE,MAAM;EACnD,iBAAE,QAAO;EACT,iBAAE,MAAM,kBAAkB,EAAE,IAAI,CAAC,EAAE,IAAI,uBAAuB;CAC/D;AAEM,IAAM,wBAAwB,iBAAE,OAAM,EAAG,IAAG,EAAG,IAAI,CAAC,EAAE,IAAI,GAAS;AAGnE,IAAM,yBAAyB,iBACnC,OAAM,EACN,IAAI,CAAC,EACL,IAAI,IAAK,EAGT,OAAO,CAAC,UAAU,CAAC,yBAAyB,KAAK,KAAK,GAAG;EACxD,SAAS;CACV;AAOI,IAAM,wBAAwB,iBAClC,OAAO;EACN,QAAQ,0BAA0B,SAAQ;EAC1C,UAAU,iBAAE,MAAM,iBAAiB,EAAE,IAAI,CAAC,EAAE,IAAI,sBAAsB,EAAE,SAAQ;EAChF,QAAQ,iBAAE,OAAO,mBAAmB,qBAAqB,EAAE,SAAQ;EACnE,KAAK,8BAA8B,SAAQ;EAC3C,QAAQ,iBAAE,QAAO,EAAG,SAAQ;EAC5B,KAAK,eAAe,SAAQ;EAC5B,SAAS,sBAAsB,SAAQ;EACvC,qBAAqB,8BAA8B,SAAQ;;EAE3D,kBAAkB,uBAAuB,SAAQ;EACjD,MAAM,iBAAE,QAAO,EAAG,SAAQ;CAC3B,EACA,OAAM,EACN,YAAY,CAAC,OAAO,YAAW;AAC9B,QAAM,OAAO,MAAM,SAAS;AAC5B,MAAI,CAAC,MAAM;AACT,QAAI,MAAM,WAAW,QAAW;AAC9B,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,QAAQ;OAChB;IACH;AACA,QAAI,MAAM,aAAa,QAAW;AAChC,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,UAAU;OAClB;IACH;EACF,OAAO;AACL,eAAW,SAAS;MAClB;MACA;MACA;MACA;MACA;MACA;OACU;AACV,UAAI,MAAM,KAAK,MAAM,QAAW;AAC9B,gBAAQ,SAAS;UACf,MAAM;UACN,SAAS;UACT,MAAM,CAAC,KAAK;SACb;MACH;IACF;EACF;AACA,MAAI,MAAM,WAAW,UAAa,MAAM,aAAa;AAAW;AAChE,QAAM,WAAW,IAAI,IAAI,MAAM,QAAQ;AACvC,aAAW,UAAU,OAAO,KAAK,MAAM,MAAM,GAAG;AAC9C,QAAI,CAAC,SAAS,IAAI,MAAM,GAAG;AACzB,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,QAAQ;OAChB;AACD;IACF;EACF;AACF,CAAC;AASG,SAAU,gCAAgC,OAAc;AAC5D,MAAI,CAAC,cAAc,KAAK;AAAG,WAAO;AAClC,MAAI,UAAU;AACd,QAAM,SAAkC,CAAA;AACxC,aAAW,CAAC,KAAK,UAAU,KAAK,OAAO,QAAQ,KAAK,GAAG;AACrD,QAAI,QAAQ,wBAAwB;AAClC,aAAO,qBAAqB,MAAM;AAClC,gBAAU;AACV;IACF;AACA,QAAI,QAAQ,YAAY;AACtB,aAAO,SAAS,MAAM;AACtB,gBAAU;AACV;IACF;AACA,WAAO,GAAG,IAAI;EAChB;AACA,SAAO,UAAU,SAAS;AAC5B;AAEA,SAAS,cAAc,OAAc;AACnC,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC5E;AAMM,SAAU,8BAA8B,OAAc;AAC1D,MAAI,CAAC,cAAc,KAAK;AAAG,WAAO;AAClC,MAAI,WAAoC;AACxC,MAAI,UAAU;AAEd,QAAM,WAAW,cAAc,SAAS,UAAU,CAAC;AACnD,MAAI,SAAS,SAAS;AACpB,eAAW,EAAE,GAAG,UAAU,UAAU,SAAS,IAAG;AAChD,cAAU;EACZ;AAEA,MAAI,cAAc,SAAS,QAAQ,CAAC,GAAG;AACrC,UAAM,SAAkC,CAAA;AACxC,QAAI,gBAAgB;AACpB,eAAW,CAAC,SAAS,KAAK,KAAK,OAAO,QAAQ,SAAS,QAAQ,CAAC,GAAG;AACjE,UAAI,CAAC,cAAc,KAAK,GAAG;AACzB,eAAO,OAAO,IAAI;AAClB;MACF;AACA,YAAM,cAAc,cAAc,MAAM,aAAa,CAAC;AACtD,UAAI,YAAY,SAAS;AACvB,eAAO,OAAO,IAAI,EAAE,GAAG,OAAO,CAAC,aAAa,GAAG,YAAY,IAAG;AAC9D,wBAAgB;AAChB;MACF;AACA,aAAO,OAAO,IAAI;IACpB;AACA,QAAI,eAAe;AACjB,iBAAW,EAAE,GAAG,UAAU,OAAM;AAChC,gBAAU;IACZ;EACF;AAEA,MAAI,cAAc,SAAS,cAAc,CAAC,GAAG;AAC3C,UAAM,eAAwC,CAAA;AAC9C,QAAI,sBAAsB;AAC1B,eAAW,CAAC,eAAe,WAAW,KAAK,OAAO,QAChD,SAAS,cAAc,CAAC,GACvB;AACD,UAAI,CAAC,cAAc,WAAW,GAAG;AAC/B,qBAAa,aAAa,IAAI;AAC9B;MACF;AACA,YAAMA,YAAW,cAAc,YAAY,UAAU,CAAC;AACtD,UAAIA,UAAS,SAAS;AACpB,qBAAa,aAAa,IAAI,EAAE,GAAG,aAAa,CAAC,UAAU,GAAGA,UAAS,IAAG;AAC1E,8BAAsB;AACtB;MACF;AACA,mBAAa,aAAa,IAAI;IAChC;AACA,QAAI,qBAAqB;AACvB,iBAAW,EAAE,GAAG,UAAU,aAAY;AACtC,gBAAU;IACZ;EACF;AAEA,SAAO,UAAU,WAAW;AAC9B;AAEA,SAAS,cACP,UAAiB;AAEjB,MAAI,CAAC,cAAc,QAAQ;AAAG,WAAO,EAAE,SAAS,OAAO,KAAK,SAAQ;AACpE,QAAM,OAAgC,CAAA;AACtC,MAAI,UAAU;AACd,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,QAAQ,GAAG;AACnD,UAAM,aAAa,gCAAgC,KAAK;AACxD,QAAI,eAAe;AAAO,gBAAU;AACpC,SAAK,GAAG,IAAI;EACd;AACA,SAAO,UAAU,EAAE,SAAS,MAAM,KAAK,KAAI,IAAK,EAAE,SAAS,OAAO,KAAK,SAAQ;AACjF;AAEO,IAAM,2BAA2B,iBACrC,OAAO;EACN,SAAS,iBACN,OAAO,+BAA+B,yBAAyB,EAC/D,SAAQ;EACX,UAAU,iBAAE,OAAO,wBAAwB,qBAAqB,EAAE,SAAQ;CAC3E,EACA,OAAM,EACN,YAAY,CAAC,aAAa,YAAW;AACpC,OACG,YAAY,YAAY,SACrB,IACA,OAAO,KAAK,YAAY,OAAO,EAAE,UAAU,6BAC/C;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,SAAS;KACjB;EACH;AACA,OACG,YAAY,aAAa,SACtB,IACA,OAAO,KAAK,YAAY,QAAQ,EAAE,UAAU,2BAChD;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,UAAU;KAClB;EACH;AACF,CAAC;AAEI,IAAM,qBAAqB,iBAC/B,OAAO;EACN,aAAa,iBAAE,OAAO,wBAAwB,qBAAqB;CACpE,EACA,OAAM,EACN,YAAY,CAAC,OAAO,YAAW;AAC9B,MAAI,OAAO,KAAK,MAAM,WAAW,EAAE,SAAS,GAAG;AAC7C,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,aAAa;KACrB;EACH;AACA,MAAI,OAAO,KAAK,MAAM,WAAW,EAAE,SAAS,2BAA2B;AACrE,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,aAAa;KACrB;EACH;AACF,CAAC;AAQI,IAAM,8BAA8B,iBACxC,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,SAAS,WAAW,SAAQ;EAC5B,cAAc,iBAAE,OAAO,uBAAuB,wBAAwB,EAAE,SAAQ;EAChF,UAAU,iBAAE,OAAO,wBAAwB,qBAAqB,EAAE,SAAQ;EAC1E,QAAQ,iBAAE,OAAO,wBAAwB,kBAAkB,EAAE,SAAQ;CACtE,EACA,OAAM,EACN,YAAY,CAAC,UAAU,YAAW;AACjC,OACG,SAAS,iBAAiB,SACvB,IACA,OAAO,KAAK,SAAS,YAAY,EAAE,UAAU,0BACjD;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,cAAc;KACtB;EACH;AACA,OACG,SAAS,WAAW,SAAY,IAAI,OAAO,KAAK,SAAS,MAAM,EAAE,UAClE,oBACA;AACA,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,QAAQ;KAChB;EACH;AACA,QAAM,eACH,SAAS,aAAa,SAAY,IAAI,OAAO,KAAK,SAAS,QAAQ,EAAE,UACtE,OAAO,OAAO,SAAS,gBAAgB,CAAA,CAAE,EAAE,OACzC,CAAC,OAAO,gBACN,SACC,YAAY,aAAa,SACtB,IACA,OAAO,KAAK,YAAY,QAAQ,EAAE,SACxC,CAAC;AAEL,MAAI,cAAc,sBAAsB;AACtC,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,UAAU;KAClB;EACH;AACF,CAAC;AAMI,IAAM,mBAAmB,iBAAE,KAAK,CAAC,QAAQ,OAAO,CAAC;AAGjD,IAAM,oBAAoB,iBAC9B,OAAO;EACN,SAAS;EACT,QAAQ;EACR,OAAO;EACP,UAAU,iBAAE,MAAM,iBAAiB,EAAE,IAAI,CAAC,EAAE,IAAI,sBAAsB;EACtE,QAAQ,iBAAE,OAAO,mBAAmB,qBAAqB,EAAE,SAAQ;EACnE,KAAK,8BAA8B,SAAQ;EAC3C,mBAAmB,uBAAuB,SAAQ;EAClD,oBAAoB,uBAAuB,SAAQ;EACnD,WAAW;EACX,WAAW,gBAAgB,SAAQ;EACnC,SAAS,sBAAsB,SAAQ;EACvC,WAAW,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW;EACvC,YAAY,gBAAgB,SAAQ;EACpC,WAAW,gBAAgB,SAAQ;CACpC,EACA,OAAM,EACN,YAAY,CAAC,OAAO,YAAW;AAC9B,MAAI,MAAM,YAAY,UAAa,MAAM,YAAY,MAAM,SAAS;AAClE,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,WAAW;KACnB;EACH;AACA,MAAI,MAAM,cAAc,UAAa,MAAM,aAAa,MAAM,WAAW;AACvE,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,WAAW;KACnB;EACH;AACA,MAAI,MAAM,cAAc,UAAa,MAAM,YAAY,MAAM,WAAW;AACtE,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,WAAW;KACnB;EACH;AACA,MAAI,MAAM,WAAW;AAAW;AAChC,QAAM,WAAW,IAAI,IAAI,MAAM,QAAQ;AACvC,aAAW,UAAU,OAAO,KAAK,MAAM,MAAM,GAAG;AAC9C,QAAI,CAAC,SAAS,IAAI,MAAM,GAAG;AACzB,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,QAAQ;OAChB;AACD;IACF;EACF;AACF,CAAC;AAKI,IAAM,2BAA2B,iBACrC,OAAO;EACN,YAAY;EACZ,WAAW;CACZ,EACA,OAAM;AAIF,IAAM,yBAAyB,OAAO,OAAO;EAClD;EACA;EACA;CACQ;AAEH,IAAM,2BAA2B,OAAO,OAAO;EACpD;CACQ;AAEH,IAAM,wBAAwB,OAAO,OAAO;EACjD;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACQ;AAEH,IAAM,4BAA4B,iBAAE,KAAK;EAC9C,GAAG;EACH,GAAG;EACH,GAAG;CACJ;AAKM,IAAM,8BAA8B,iBAAE,mBAAmB,WAAW;EACzE,iBACG,OAAO;IACN,SAAS,iBAAE,QAAQ,OAAO;IAC1B,QAAQ,iBAAE,KAAK,sBAAsB;IACrC,UAAU,uBAAuB,SAAQ;IACzC,SAAS,uBAAuB,SAAQ;IACxC,QAAQ,0BAA0B,SAAQ;GAC3C,EACA,OAAM;EACT,iBACG,OAAO;IACN,SAAS,iBAAE,QAAQ,SAAS;IAC5B,QAAQ,iBAAE,KAAK,wBAAwB;IACvC,UAAU,uBAAuB,SAAQ;IACzC,QAAQ,0BAA0B,SAAQ;GAC3C,EACA,OAAM;EACT,iBACG,OAAO;IACN,SAAS,iBAAE,QAAQ,MAAM;IACzB,QAAQ,iBAAE,KAAK,qBAAqB;IACpC,UAAU,uBAAuB,SAAQ;IACzC,SAAS,uBAAuB,SAAQ;IACxC,QAAQ,0BAA0B,SAAQ;GAC3C,EACA,OAAM;CACV;AAIM,IAAM,0BAA0B,iBAAE,KAAK,CAAC,QAAQ,OAAO,CAAC;AAExD,IAAM,2BAA2B,iBAAE,KAAK;EAC7C;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACD;AAED,IAAM,6BAA6B,iBAChC,OAAM,EACN,IAAI,CAAC,EACL,IAAI,sBAAsB,EAG1B,OAAO,CAAC,UAAU,CAAC,yBAAyB,KAAK,KAAK,GAAG;EACxD,SAAS;CACV;AAMI,IAAM,0BAA0B,iBACpC,OAAO;EACN,KAAK,iBAAE,OAAM,EAAG,IAAG,EAAG,SAAQ;EAC9B,YAAY;EACZ,OAAO;EACP,QAAQ;EACR,UAAU,uBAAuB,SAAQ;EACzC,SAAS,uBAAuB,SAAQ;EACxC,eAAe,uBAAuB,SAAQ;EAC9C,QAAQ,0BAA0B,SAAQ;EAC1C,SAAS,kBAAkB,SAAQ;EACnC,aAAa,iBACV,MAAM,0BAA0B,EAChC,IAAI,wBAAwB,EAC5B,SAAQ;EACX,UAAU,iBAAE,OAAM,EAAG,IAAG,EAAG,IAAI,WAAW,EAAE,IAAI,UAAU,EAAE,SAAQ;EACpE,QAAQ,0BAA0B,SAAQ;CAC3C,EACA,OAAM;AAMF,IAAM,+BAA+B,iBAAE,KAAK,CAAC,YAAY,OAAO,CAAC;AAIjE,IAAM,iCAAiC,iBAAE,QAC9C,+BAA+B;AAI1B,IAAM,qCAAqC,iBAC/C,OAAO;EACN,QAAQ;EACR,WAAW;EACX,SAAS;EACT,UAAU,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW;CACvC,EACA,OAAM;AAOF,IAAM,mCAAmC,iBAC7C,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,UAAU,iBAAE,OAAO,wBAAwB,wBAAwB;EACnE,QAAQ,iBAAE,OAAO,eAAe,iBAAiB;EACjD,OAAO,iBAAE,MAAM,uBAAuB,EAAE,IAAI,wBAAwB;CACrE,EACA,OAAM,EACN,YAAY,CAAC,OAAO,YAAW;AAC9B,MAAI,OAAO,KAAK,MAAM,QAAQ,EAAE,SAAS,qBAAqB;AAC5D,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,UAAU;KAClB;EACH;AACA,MAAI,OAAO,KAAK,MAAM,MAAM,EAAE,SAAS,mBAAmB;AACxD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,QAAQ;KAChB;EACH;AACF,CAAC;AAMI,IAAM,iCAAiC,iBAAE,QAAQ,4BAA4B;AAO7E,IAAM,mCAAmC,iBAC7C,OAAO;EACN,QAAQ;EACR,SAAS,iBAAE,QAAQ,CAAC;EACpB,WAAW;EACX,SAAS;EACT,UAAU,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW;EACtC,WAAW;EACX,WAAW;EACX,OAAO,gBAAgB,OAAO,0BAA0B;EACxD,YAAY;EACZ,mBAAmB,gBAAgB,OAAO,uCAAuC;CAClF,EACA,OAAM;AAQT,IAAM,uBACJ;AAEK,IAAM,0BAA0B;AAChC,IAAM,uBAAuB;AAC7B,IAAM,yBAAyB,IAAI,OAAO;AAG1C,IAAM,2BAA2B,iBACrC,OAAO;EACN,GAAG,iBAAE,QAAQ,CAAC;EACd,OAAO,iBAAE,OAAM,EAAG,IAAI,EAAE,EAAE,IAAI,GAAG;EACjC,IAAI,iBAAE,QAAQ,MAAM;EACpB,YAAY;EACZ,MAAM,iBACH,MAAM,iBAAE,OAAM,EAAG,IAAI,CAAC,EAAE,IAAI,oBAAoB,CAAC,EACjD,IAAI,CAAC,EACL,IAAI,uBAAuB;CAC/B,EACA,OAAM;AAKF,IAAM,iCAAiC,iBAC3C,OAAO;EACN,GAAG,iBAAE,QAAQ,CAAC;EACd,OAAO,iBAAE,QAAQ,UAAU;EAC3B,SAAS,iBAAE,KAAK,CAAC,SAAS,MAAM,CAAC;EACjC,QAAQ;CACT,EACA,OAAM;AAEF,IAAM,+BAA+B,iBACzC,OAAO;EACN,GAAG,iBAAE,QAAQ,CAAC;EACd,OAAO,iBAAE,KAAK,CAAC,UAAU,QAAQ,CAAC;EAClC,MAAM,iBAAE,OAAM,EAAG,MAAM,sBAAsB,8BAA8B;CAC5E,EACA,OAAM;AAEF,IAAM,6BAA6B,iBACvC,OAAO;EACN,GAAG,iBAAE,QAAQ,CAAC;EACd,OAAO,iBAAE,QAAQ,MAAM;EACvB,UAAU,iBAAE,OAAM,EAAG,IAAG,EAAG,IAAI,WAAW,EAAE,IAAI,UAAU,EAAE,SAAQ;EACpE,QAAQ,iBAAE,OAAM,EAAG,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE,SAAQ;CAC3C,EACA,OAAM;AAEF,IAAM,+BAA+B,iBAAE,mBAAmB,SAAS;EACxE;EACA;EACA;CACD;AAKM,IAAM,+BAA+B,iBAAE,mBAAmB,SAAS;EACxE,iBACG,OAAO;IACN,GAAG,iBAAE,QAAQ,CAAC;IACd,OAAO,iBAAE,QAAQ,OAAO;IACxB,MAAM,iBAAE,OAAM,EAAG,MAAM,oBAAoB;GAC5C,EACA,OAAM;EACT,iBAAE,OAAO,EAAE,GAAG,iBAAE,QAAQ,CAAC,GAAG,OAAO,iBAAE,QAAQ,aAAa,EAAC,CAAE,EAAE,OAAM;CACtE;;;ACvxBM,IAAM,iCAAiC,iBAAE,KAAK;EACnD;EACA;EACA;EACA;CACD;AAED,IAAM,4BAA4B,iBAC/B,OAAM,EACN,IAAI,EAAE,EACN,IAAI,GAAG,EACP,MAAM,gCAAgC;AAElC,IAAM,6CAA6C,iBACvD,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,SAAS;EACT,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,gBAAgB;EAChB,gBAAgB;EAChB,kBAAkB;EAClB,uBAAuB;EACvB,kBAAkB;EAClB,OAAO;CACR,EACA,OAAM,EACN,YAAY,CAAC,SAAS,YAAW;AAChC,MAAI,QAAQ,iBAAiB,QAAQ,mBAAmB;AACtD,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,mBAAmB;MAC1B,SAAS;KACV;EACH;AACA,QAAM,SAAS;IACb,UAAU;IACV,qBAAqB;IACrB,oBAAoB;IACpB,WAAW;IACX,QAAQ,KAAK;AACf,MAAI,QAAQ,iBAAiB,WAAW,QAAQ,gBAAgB;AAC9D,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,gBAAgB;MACvB,SAAS;KACV;EACH;AACF,CAAC;AAEI,IAAM,sCAAsC,iBAChD,OAAO;EACN,SAAS;EACT,mBAAmB;CACpB,EACA,OAAM;AAYF,IAAM,sCAAsC,iBAAE,KAAK;EACxD;EACA;CACD;AAED,IAAM,qBAAqB,cAAc,OACvC,CAAC,SAAkC,KAAK,SAAS,gBACjD;EACE,OAAO;CACR;AAGI,IAAM,yCAAyC,iBACnD,OAAO;EACN,SAAS,iBAAE,QAAQ,CAAC;EACpB,MAAM,iBAAE,QAAQ,uBAAuB;EACvC,aAAa;EACb,SAAS;EACT,UAAU;EACV,OAAO;EACP,YAAY;EACZ,YAAY;EACZ,iBAAiB;EACjB,gBAAgB;EAChB,WAAW;EACX,WAAW;EACX,YAAY;CACb,EACA,OAAM,EACN,YAAY,CAAC,QAAQ,YAAW;AAC/B,QAAM,2BACJ,OAAO,UAAU,cAAc,OAAO,UAAU,sBAC5C,YACA;AACN,MACE,OAAO,WAAW,UAAU,YAC5B,OAAO,gBAAgB,UAAU,4BACjC,OAAO,WAAW,OAAO,OAAO,gBAAgB,MAChD,OAAO,WAAW,eAAe,OAAO,gBAAgB,cACxD,OAAO,mBAAmB,OAAO,WAAW,QAAQ,kBACpD,OAAO,WAAW,QAAQ,YAAY,OAAO,WAC7C,OAAO,WAAW,QAAQ,gBAAgB,OAAO,eACjD,OAAO,WAAW,QAAQ,iBAAiB,OAAO,WAAW,MAC7D,OAAO,WAAW,QAAQ,sBAAsB,OAAO,gBAAgB,MACvE,OAAO,WAAW,QAAQ,UAAU,OAAO,OAC3C;AACA,YAAQ,SAAS;MACf,MAAM;MACN,MAAM,CAAC,YAAY;MACnB,SAAS;KACV;EACH;AACF,CAAC;AAMI,IAAM,qDAAqD,KAAK;;;AC7HhE,IAAM,yBAAyB;AAC/B,IAAM,yBAAyB;AAO/B,IAAM,gCAAgC;AACtC,IAAM,0BAA0B;AAChC,IAAM,qCAAqC;AAW3C,IAAM,4BAA4B,iBAAE,KAAK;;EAE9C;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;CACD;AAWM,IAAM,8BAA8B,iBACxC,OAAO;EACN,qBAAqB,iBAClB,OAAM,EACN,IAAG,EACH,IAAI,sBAAsB,EAC1B,IAAI,sBAAsB;EAC7B,eAAe,iBACZ,OAAM,EACN,IAAG,EACH,IAAI,sBAAsB,EAC1B,IAAI,sBAAsB;EAC7B,0BAA0B,iBACvB,OAAM,EACN,IAAG,EACH,IAAI,sBAAsB,EAC1B,IAAI,sBAAsB;CAC9B,EACA,OAAM,EACN,YAAY,CAAC,QAAQ,YAAW;AAC/B,MAAI,OAAO,gBAAgB,OAAO,qBAAqB;AACrD,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,eAAe;KACvB;EACH;AACA,MAAI,OAAO,2BAA2B,OAAO,qBAAqB;AAChE,YAAQ,SAAS;MACf,MAAM;MACN,SAAS;MACT,MAAM,CAAC,0BAA0B;KAClC;EACH;AACF,CAAC;AAEI,IAAM,kCAAyD,OAAO,OAAO;EAClF,qBAAqB;EACrB,eAAe;EACf,0BAA0B;CAC3B;;;AC/EM,IAAM,iCAAiC;AACvC,IAAM,+BAA+B,MAAM,OAAO;AAEzD,IAAMC,8BAA6B,gBAChC,OAAO,EAAE,EACT,OAAO,CAAC,UAAU,OAAO,KAAK,OAAO,WAAW,EAAE,eAAe,IAAI;EACpE,OAAO;CACR;AAEI,IAAM,wBACXA,4BAA2B,MAAK;AAC3B,IAAM,kCACXA,4BAA2B,MAAK;AAY3B,IAAM,2BAA2B,iBACrC,OAAO;EACN,WAAW,iBAAE,QAAQ,8CAA8C;EACnE,YAAY;EACZ,eAAe;CAChB,EACA,OAAM;AAEF,IAAM,gCAAgC,iBAC1C,OAAO;EACN,MAAM,iBAAE,QAAQ,QAAQ;EACxB,QAAQ,iBAAE,QAAQ,2BAA2B;EAC7C,SAAS,iBAAE,QAAQ,CAAC;EACpB,SAAS;EACT,eAAe;EACf,WAAW;EACX,YAAY;CACb,EACA,OAAM;AASF,IAAM,kCAAkC,iBAAE,KAAK;;EAEpD;;EAEA;;EAEA;CACD;AAEM,IAAM,4BAA4B,iBACtC,OAAO;EACN,WAAW;EACX,OAAO,iBAAE,KAAK,CAAC,YAAY,MAAM,CAAC;EAClC,QAAQ;CACT,EACA,OAAM;AAOF,IAAM,6BAA6B,iBACvC,MAAM,yBAAyB,EAC/B,IAAI,GAAK,EACT,YAAY,CAAC,cAAc,YAAW;AACrC,QAAM,OAAO,oBAAI,IAAG;AACpB,aAAW,CAAC,OAAO,QAAQ,KAAK,aAAa,QAAO,GAAI;AACtD,UAAM,MAAM,GAAG,SAAS,KAAK,IAAI,SAAS,SAAS;AACnD,QAAI,KAAK,IAAI,GAAG,GAAG;AACjB,cAAQ,SAAS;QACf,MAAM;QACN,SAAS;QACT,MAAM,CAAC,OAAO,WAAW;OAC1B;IACH;AACA,SAAK,IAAI,GAAG;EACd;AACF,CAAC;AASI,IAAM,+BAA+B,iBAAE,mBAAmB,QAAQ;EACvE,iBACG,OAAO;IACN,MAAM,iBAAE,QAAQ,OAAO;IACvB,SAAS;IACT,UAAU;GACX,EACA,OAAM;EACT,iBACG,OAAO;IACN,MAAM,iBAAE,QAAQ,MAAM;IACtB,SAAS;IACT,QAAQ;IACR,UAAU;IACV,UAAU;GACX,EACA,OAAM;CACV;AAEM,IAAM,gCAAgC,iBAC1C,OAAO;EACN,MAAM,iBAAE,QAAQ,QAAQ;EACxB,SAAS,iBAAE,QAAQ,CAAC;EACpB,YAAY,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW,EAAG,IAAI,8BAA8B;EAC7E,WAAW,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW,EAAG,IAAI,8BAA8B;EAC5E,kBAAkBA;EAClB,mBAAmB;CACpB,EACA,OAAM;AAEF,IAAM,uBAAuB,iBACjC,OAAO;EACN,cAAc,iBAAE,OAAM,EAAG,IAAG,EAAG,SAAQ,EAAG,IAAI,4BAA4B;EAC1E,kBAAkB,iBAAE,OAAM,EAAG,IAAG,EAAG,SAAQ,EAAG,IAAI,8BAA8B;CACjF,EACA,OAAM;AAGF,IAAM,kCAAkC,iBAAE,KAAK,CAAC,QAAQ,QAAQ,QAAQ,CAAC;AAEzE,IAAM,8BAA8B,iBACxC,OAAO;EACN,SAAS;EACT,WAAW;EACX,eAAe,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW;EAC3C,eAAe,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW;EAC3C,cAAc,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW;EAC1C,gBAAgB,iBAAE,OAAM,EAAG,IAAG,EAAG,YAAW;CAC7C,EACA,OAAM;",
  "names": ["policies", "canonical32ByteValueSchema"]
}
