@anizoptera/uuid-slug 0.3.0 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (202) hide show
  1. package/LICENSE +54 -31
  2. package/README.md +1052 -261
  3. package/dist/alphabet.d.ts +5 -17
  4. package/dist/alphabet.d.ts.map +1 -1
  5. package/dist/alphabet.js +146 -112
  6. package/dist/alphabet.js.map +1 -1
  7. package/dist/base64url-name.d.ts +7 -0
  8. package/dist/base64url-name.d.ts.map +1 -0
  9. package/dist/base64url-name.js +8 -0
  10. package/dist/base64url-name.js.map +1 -0
  11. package/dist/errors.d.ts +50 -9
  12. package/dist/errors.d.ts.map +1 -1
  13. package/dist/errors.js +145 -63
  14. package/dist/errors.js.map +1 -1
  15. package/dist/feistel.js +29 -95
  16. package/dist/feistel.js.map +1 -1
  17. package/dist/generation-options.js +20 -0
  18. package/dist/generation-options.js.map +1 -0
  19. package/dist/index.d.ts +22 -10
  20. package/dist/index.js +21 -9
  21. package/dist/instant.js +83 -0
  22. package/dist/instant.js.map +1 -0
  23. package/dist/mask-handle.d.ts +16 -0
  24. package/dist/mask-handle.d.ts.map +1 -0
  25. package/dist/mask-handle.js +60 -0
  26. package/dist/mask-handle.js.map +1 -0
  27. package/dist/mask.d.ts +27 -0
  28. package/dist/mask.d.ts.map +1 -0
  29. package/dist/mask.js +151 -95
  30. package/dist/mask.js.map +1 -1
  31. package/dist/masking-codec-protocol.js +23 -0
  32. package/dist/masking-codec-protocol.js.map +1 -0
  33. package/dist/masking-codec-types.d.ts +245 -0
  34. package/dist/masking-codec-types.d.ts.map +1 -0
  35. package/dist/masking-codec.d.ts +19 -0
  36. package/dist/masking-codec.d.ts.map +1 -0
  37. package/dist/masking-codec.js +391 -0
  38. package/dist/masking-codec.js.map +1 -0
  39. package/dist/migration.js +114 -51
  40. package/dist/migration.js.map +1 -1
  41. package/dist/node/runtime.js +39 -0
  42. package/dist/node/runtime.js.map +1 -0
  43. package/dist/payload.d.ts +7 -0
  44. package/dist/payload.d.ts.map +1 -0
  45. package/dist/payload.js +118 -0
  46. package/dist/payload.js.map +1 -0
  47. package/dist/runtime/pool.js +21 -46
  48. package/dist/runtime/pool.js.map +1 -1
  49. package/dist/runtime/portable.js +27 -0
  50. package/dist/runtime/portable.js.map +1 -0
  51. package/dist/sentinel.js +10 -0
  52. package/dist/sentinel.js.map +1 -0
  53. package/dist/siphash.js +20 -99
  54. package/dist/siphash.js.map +1 -1
  55. package/dist/slug.d.ts +169 -0
  56. package/dist/slug.d.ts.map +1 -0
  57. package/dist/slug.js +268 -0
  58. package/dist/slug.js.map +1 -0
  59. package/dist/timestamp.d.ts +19 -0
  60. package/dist/timestamp.d.ts.map +1 -0
  61. package/dist/timestamp.js +44 -0
  62. package/dist/timestamp.js.map +1 -0
  63. package/dist/types.d.ts +480 -200
  64. package/dist/types.d.ts.map +1 -1
  65. package/dist/types.js +8 -0
  66. package/dist/types.js.map +1 -0
  67. package/dist/uuid-value-protocol.js +46 -0
  68. package/dist/uuid-value-protocol.js.map +1 -0
  69. package/dist/uuid-value.d.ts +17 -0
  70. package/dist/uuid-value.d.ts.map +1 -0
  71. package/dist/uuid-value.js +127 -0
  72. package/dist/uuid-value.js.map +1 -0
  73. package/dist/uuid.d.ts +51 -64
  74. package/dist/uuid.d.ts.map +1 -1
  75. package/dist/uuid.js +203 -199
  76. package/dist/uuid.js.map +1 -1
  77. package/dist/v4-slug.d.ts +16 -0
  78. package/dist/v4-slug.d.ts.map +1 -0
  79. package/dist/v4-slug.js +16 -0
  80. package/dist/v4-slug.js.map +1 -0
  81. package/dist/v4.d.ts +42 -0
  82. package/dist/v4.d.ts.map +1 -0
  83. package/dist/v4.js +85 -0
  84. package/dist/v4.js.map +1 -0
  85. package/dist/v7-bounds.d.ts +36 -0
  86. package/dist/v7-bounds.d.ts.map +1 -0
  87. package/dist/v7-bounds.js +49 -0
  88. package/dist/v7-bounds.js.map +1 -0
  89. package/dist/v7-generator-input.js +75 -0
  90. package/dist/v7-generator-input.js.map +1 -0
  91. package/dist/v7-generator.d.ts +43 -0
  92. package/dist/v7-generator.d.ts.map +1 -0
  93. package/dist/v7-generator.js +105 -0
  94. package/dist/v7-generator.js.map +1 -0
  95. package/dist/v7-keyless.d.ts +46 -0
  96. package/dist/v7-keyless.d.ts.map +1 -0
  97. package/dist/v7-keyless.js +106 -0
  98. package/dist/v7-keyless.js.map +1 -0
  99. package/dist/v7-payload.js +54 -0
  100. package/dist/v7-payload.js.map +1 -0
  101. package/dist/v7-slug.d.ts +46 -0
  102. package/dist/v7-slug.d.ts.map +1 -0
  103. package/dist/v7-slug.js +127 -0
  104. package/dist/v7-slug.js.map +1 -0
  105. package/dist/v7-timestamp.js +9 -0
  106. package/dist/v7-timestamp.js.map +1 -0
  107. package/dist/v7-value-options.js +28 -0
  108. package/dist/v7-value-options.js.map +1 -0
  109. package/dist/v7-value.d.ts +23 -0
  110. package/dist/v7-value.d.ts.map +1 -0
  111. package/dist/v7-value.js +31 -0
  112. package/dist/v7-value.js.map +1 -0
  113. package/dist/v7.js +127 -171
  114. package/dist/v7.js.map +1 -1
  115. package/package.json +14 -9
  116. package/src/alphabet.ts +456 -27
  117. package/src/base64url-name.ts +5 -0
  118. package/src/errors.ts +373 -37
  119. package/src/feistel.ts +69 -56
  120. package/src/generation-options.ts +48 -0
  121. package/src/index.ts +134 -80
  122. package/src/instant.ts +196 -0
  123. package/src/keyless.ts +7 -134
  124. package/src/mask-handle.ts +141 -0
  125. package/src/mask.ts +354 -129
  126. package/src/masking-codec-protocol.ts +29 -0
  127. package/src/masking-codec-types.ts +380 -0
  128. package/src/masking-codec.ts +923 -0
  129. package/src/migration.ts +195 -42
  130. package/src/payload.ts +321 -0
  131. package/src/runtime/bun.ts +30 -49
  132. package/src/runtime/node.ts +43 -24
  133. package/src/runtime/pool.ts +49 -21
  134. package/src/runtime/portable.ts +68 -0
  135. package/src/runtime/types.ts +23 -35
  136. package/src/sentinel.ts +13 -0
  137. package/src/siphash.ts +5 -4
  138. package/src/slug.ts +884 -0
  139. package/src/timestamp.ts +122 -0
  140. package/src/types.ts +759 -205
  141. package/src/uuid-value-protocol.ts +77 -0
  142. package/src/uuid-value.ts +341 -0
  143. package/src/uuid.ts +514 -234
  144. package/src/v4-slug.ts +27 -0
  145. package/src/v4.ts +234 -0
  146. package/src/v7-bounds.ts +171 -0
  147. package/src/v7-generator-input.ts +169 -0
  148. package/src/v7-generator.ts +245 -0
  149. package/src/v7-keyless.ts +354 -0
  150. package/src/v7-payload.ts +121 -0
  151. package/src/v7-slug.ts +293 -0
  152. package/src/v7-timestamp.ts +21 -0
  153. package/src/v7-value-options.ts +62 -0
  154. package/src/v7-value.ts +54 -0
  155. package/src/v7.ts +377 -200
  156. package/dist/base64url.d.ts +0 -20
  157. package/dist/base64url.d.ts.map +0 -1
  158. package/dist/base64url.js +0 -33
  159. package/dist/base64url.js.map +0 -1
  160. package/dist/codec.d.ts +0 -17
  161. package/dist/codec.d.ts.map +0 -1
  162. package/dist/codec.js +0 -192
  163. package/dist/codec.js.map +0 -1
  164. package/dist/keyless.d.ts +0 -31
  165. package/dist/keyless.d.ts.map +0 -1
  166. package/dist/keyless.js +0 -93
  167. package/dist/keyless.js.map +0 -1
  168. package/dist/legacy-mask.js +0 -55
  169. package/dist/legacy-mask.js.map +0 -1
  170. package/dist/node/alphabet.js +0 -130
  171. package/dist/node/base64url.js +0 -31
  172. package/dist/node/codec.js +0 -190
  173. package/dist/node/errors.js +0 -78
  174. package/dist/node/feistel.js +0 -103
  175. package/dist/node/index.js +0 -10
  176. package/dist/node/keyless.js +0 -91
  177. package/dist/node/legacy-mask.js +0 -53
  178. package/dist/node/mask.js +0 -106
  179. package/dist/node/migration.js +0 -64
  180. package/dist/node/runtime/node.js +0 -33
  181. package/dist/node/runtime/pool.js +0 -53
  182. package/dist/node/schema.js +0 -214
  183. package/dist/node/siphash.js +0 -106
  184. package/dist/node/uuid.js +0 -226
  185. package/dist/node/v7.js +0 -185
  186. package/dist/node/yield.js +0 -20
  187. package/dist/runtime/web.js +0 -39
  188. package/dist/runtime/web.js.map +0 -1
  189. package/dist/schema.d.ts +0 -20
  190. package/dist/schema.d.ts.map +0 -1
  191. package/dist/schema.js +0 -216
  192. package/dist/schema.js.map +0 -1
  193. package/dist/v7.d.ts +0 -12
  194. package/dist/v7.d.ts.map +0 -1
  195. package/dist/yield.js +0 -22
  196. package/dist/yield.js.map +0 -1
  197. package/src/base64url.ts +0 -41
  198. package/src/codec.ts +0 -320
  199. package/src/legacy-mask.ts +0 -25
  200. package/src/runtime/web.ts +0 -48
  201. package/src/schema.ts +0 -300
  202. package/src/yield.ts +0 -22
@@ -0,0 +1,245 @@
1
+ // SPDX-License-Identifier: Apache-2.0
2
+ // @anizoptera/uuid-slug 0.4.0 | https://github.com/Anizoptera/uuid-slug#readme
3
+ import { UuidSlugError } from "./errors.js";
4
+ import { SlugAlphabet } from "./slug.js";
5
+ import { EnabledMigrationFormat, GenerateUuidV7WithMaskedSlugOptions, GeneratedUuidV7, MaskedOrSentinelUuidV7Slug, MaskingCodecUuidInput, ParsedUuidResult, PlainUuidSlug, PlainUuidSlugResult, PlainUuidV7Slug, PlainUuidV7SlugInput, SEEDED_MASK_FORMAT, SlugStringInput, UUID_TEXT_LOWERCASE, Uuid, UuidBytesResult, UuidInput, UuidOutput, UuidSlugMigrationDecoder, UuidSlugMigrationOptions, UuidStringResult, UuidTextCase, UuidTextCaseArguments, UuidV7Bytes, UuidV7Mask, UuidV7MaskOptions, UuidV7MaskingCodecValueOptions, UuidV7Payload, UuidV7PayloadLayout, UuidV7Sentinel, UuidV7SentinelConfig, UuidV7StringFor, UuidV7TimestampWindow, UuidV7ValueInput } from "./types.js";
6
+ //#region src/masking-codec-types.d.ts
7
+ /** Key rotation, sentinel, and output options shared by both ways of supplying the writer mask. */
8
+ export interface UuidV7MaskingCodecSharedOptions {
9
+ /**
10
+ * First Unix millisecond accepted by masking. The inclusive end is this value plus
11
+ * `MAX_MASKED_UUID_V7_TIMESTAMP_OFFSET_MS`. Changing it changes masked slugs, so retain the old
12
+ * value with its mask in `previousMasks` while stored slugs still use it.
13
+ *
14
+ * @defaultValue `0`
15
+ */
16
+ readonly timestampRangeStartUnixMs?: number;
17
+ /**
18
+ * Decode-only masks tried after the writer mask, in caller order. Each item accepts a mask or its
19
+ * derivation options. A returned `UuidSlugError` passes through unchanged. Keep the list short:
20
+ * every mask adds decoding work and another chance for a random input to pass its 16-bit check.
21
+ *
22
+ * @defaultValue No previous masks.
23
+ */
24
+ readonly previousMasks?: readonly (UuidV7Mask | UuidV7MaskOptions | UuidV7PreviousMask | UuidSlugError)[];
25
+ /**
26
+ * Named UUIDv7 values emitted as raw plain slugs instead of masked payloads.
27
+ *
28
+ * @defaultValue No sentinels.
29
+ */
30
+ readonly sentinels?: readonly UuidV7SentinelConfig[];
31
+ /**
32
+ * Output spelling for masked UUID slugs and plain sentinel UUID slugs.
33
+ * `"base32hex"` preserves the full masked payload in 27 lowercase characters (26 for raw
34
+ * sentinels), suitable for case-insensitive filesystems. Masked output has no sort-order promise.
35
+ * Readers accept both spellings regardless of this writer selection.
36
+ *
37
+ * @defaultValue `"base64url"`
38
+ */
39
+ readonly maskedSlugAlphabet?: SlugAlphabet;
40
+ }
41
+ /**
42
+ * Configure one immutable UUIDv7 masking codec for writing, key rotation, and sentinels. Supply the
43
+ * writer mask exactly one way: `maskSeed` for private key material, or `mask` for a shared derived
44
+ * mask, `UUID_V7_TEST_MASK`, or seed material that also needs a label or a key-derivation work factor.
45
+ */
46
+ export type UuidV7MaskingCodecOptions = (UuidV7MaskingCodecSharedOptions & {
47
+ /**
48
+ * The writer mask and first reader. Supply a derived mask, its derivation options, or
49
+ * explicitly choose `UUID_V7_TEST_MASK` for public test data. A returned `UuidSlugError`
50
+ * passes through unchanged.
51
+ */
52
+ readonly mask: UuidV7Mask | UuidV7MaskOptions | UuidSlugError;
53
+ readonly maskSeed?: never;
54
+ }) | (UuidV7MaskingCodecSharedOptions & {
55
+ readonly mask?: never;
56
+ /**
57
+ * Stable secret key material for the writer mask, derived with the default work factor.
58
+ * Generate at least 16 bytes, keep it outside source control, and retain old values in
59
+ * `previousMasks`; a known UUID/slug pair permits offline guesses. JavaScript also accepts a
60
+ * genuine `String` object.
61
+ */
62
+ readonly maskSeed: string | Uint8Array;
63
+ });
64
+ /** A retained mask and the timestamp-range start used to create its stored slugs. */
65
+ export interface UuidV7PreviousMask {
66
+ /** Retained decode-only mask or its derivation options. */
67
+ readonly mask: UuidV7Mask | UuidV7MaskOptions | UuidSlugError;
68
+ /** First Unix millisecond accepted by this retained mask. Omit for `0`. */
69
+ readonly timestampRangeStartUnixMs?: number;
70
+ }
71
+ /**
72
+ * An immutable UUIDv7 masking codec that owns its masks, sentinels, output alphabet, and byte source.
73
+ * Methods may be detached. Decoding proves format integrity, not issuance or authorization.
74
+ * JavaScript UUID and slug text inputs normalize genuine `String` objects; TypeScript uses primitives.
75
+ */
76
+ export interface UuidV7MaskingCodec {
77
+ /** Frozen sentinel metadata in the masking codec's configured masked-slug alphabet. */
78
+ readonly sentinels: readonly UuidV7Sentinel[];
79
+ /** Generate an immutable UUIDv7 with this masking codec retained. */
80
+ generateUuidV7Value(this: void, options?: UuidV7MaskingCodecValueOptions): Uuid<7, true, true> | UuidSlugError;
81
+ /** Parse any accepted UUID form, retain this codec and preserve an existing payload layout. A plain-v4 slug brand cannot exclude a masked-v7 reading. */
82
+ parseUuid<Input extends UuidInput>(this: void, uuid: Input): ParsedUuidResult<Input, true> | UuidSlugError;
83
+ /**
84
+ * Convert any accepted UUID form to normalized UUID text. A 22-character slug is read as masked
85
+ * when it passes this codec's check and as plain otherwise.
86
+ * A plain UUIDv4 slug can therefore return UUIDv4 or UUIDv7 text.
87
+ */
88
+ uuidToString<Input extends UuidInput, Case extends UuidTextCase = typeof UUID_TEXT_LOWERCASE>(this: void, uuid: Input, ...textCase: UuidTextCaseArguments<Case>): UuidStringResult<MaskingCodecUuidInput<Input>, Case>;
89
+ /**
90
+ * Read one UUID out of a larger array as normalized UUID text. Bytes carry no masked spelling.
91
+ *
92
+ * @param byteOffset - Zero-based index where the UUID starts. Omit for a standalone UUID.
93
+ */
94
+ uuidToString<Case extends UuidTextCase = typeof UUID_TEXT_LOWERCASE>(this: void, uuid: Uint8Array, byteOffset: number, ...textCase: UuidTextCaseArguments<Case>): UuidStringResult<Uint8Array, Case>;
95
+ /**
96
+ * Convert any accepted UUID form to a new plain 16-byte array. A 22-character slug is read as
97
+ * masked when it passes this codec's check and as plain otherwise.
98
+ * A plain UUIDv4 slug can therefore return UUIDv4 or UUIDv7 bytes.
99
+ */
100
+ uuidToBytes<Input extends UuidInput>(this: void, uuid: Input): UuidBytesResult<MaskingCodecUuidInput<Input>>;
101
+ /** Convert any accepted UUID form into caller-owned storage after complete validation. */
102
+ uuidToBytes<Output extends Uint8Array>(this: void, uuid: UuidInput, output: Output, outputOffset?: number): UuidOutput<Output> | UuidSlugError;
103
+ /**
104
+ * Copy one UUID out of a larger array. Bytes carry no masked spelling.
105
+ *
106
+ * @param byteOffset - Zero-based index where the UUID starts. Omit for a standalone UUID.
107
+ */
108
+ uuidToBytes(this: void, uuid: Uint8Array, byteOffset: number): UuidBytesResult<Uint8Array>;
109
+ /** Copy one UUID out of a larger array into caller-owned storage. */
110
+ uuidToBytes<Output extends Uint8Array>(this: void, uuid: Uint8Array, byteOffset: number, output: Output, outputOffset?: number): UuidOutput<Output> | UuidSlugError;
111
+ /**
112
+ * Convert any accepted UUID form to a plain UUID slug. A 22-character slug is read as masked
113
+ * when it passes this codec's check and as plain otherwise.
114
+ * A plain UUIDv4 slug can therefore return a plain UUIDv4 or UUIDv7 slug.
115
+ */
116
+ uuidToPlainSlug<Input extends UuidInput>(this: void, uuid: Input, alphabet?: SlugAlphabet): PlainUuidSlugResult<MaskingCodecUuidInput<Input>>;
117
+ /**
118
+ * Read one UUID out of a larger array as a plain UUID slug. Bytes carry no masked spelling.
119
+ *
120
+ * @param byteOffset - Zero-based index where the UUID starts. Omit for a standalone UUID.
121
+ */
122
+ uuidToPlainSlug(this: void, uuid: Uint8Array, byteOffset: number, alphabet?: SlugAlphabet): PlainUuidSlugResult<Uint8Array>;
123
+ /**
124
+ * Create a reader for current and explicitly enabled old formats without changing this codec.
125
+ * Omitted options return the reader directly. Configured construction returns `invalid_options`
126
+ * for unknown keys, nonboolean settings or inaccessible properties. Check construction once
127
+ * before reusing the reader; decode failures return `UuidSlugError` from the reader.
128
+ *
129
+ * @param options - Old formats this application has actually issued. Omit for current formats only.
130
+ */
131
+ createUuidSlugMigrationDecoder(this: void, options?: undefined): UuidSlugMigrationDecoder<typeof SEEDED_MASK_FORMAT>;
132
+ /** Create a reusable reader with explicitly enabled old formats; check configuration failure once. */
133
+ createUuidSlugMigrationDecoder<const Options extends UuidSlugMigrationOptions>(this: void, options: Options | undefined): UuidSlugMigrationDecoder<EnabledMigrationFormat<Options>> | UuidSlugError;
134
+ /**
135
+ * Generate and encode a UUIDv7 as a masked slug or its registered raw sentinel slug.
136
+ * Options may select an explicit time and a generator whose sequence this call joins.
137
+ * Returns `invalid_timestamp` outside the codec's inclusive configured timestamp range unless
138
+ * the generated UUID is a registered sentinel, which
139
+ * is returned as a plain slug without masking.
140
+ */
141
+ generateMaskedUuidV7Slug(this: void, options?: UuidV7MaskingCodecValueOptions): MaskedOrSentinelUuidV7Slug | UuidSlugError;
142
+ /**
143
+ * Generate UUIDv7 text and its masked or sentinel slug from one random byte draw. UUID text is
144
+ * lowercase unless `textCase` selects uppercase. Options may select an explicit time and a
145
+ * generator whose sequence this call joins.
146
+ * Returns `invalid_timestamp` outside the codec's inclusive configured timestamp range unless
147
+ * the generated UUID is a registered sentinel, which
148
+ * is returned as a plain slug without masking.
149
+ *
150
+ * @param textCase - Built-in UUID text spelling. Omit for lowercase.
151
+ */
152
+ generateUuidV7WithMaskedSlug<Case extends UuidTextCase = typeof UUID_TEXT_LOWERCASE>(this: void, ...textCase: UuidTextCaseArguments<Case>): GeneratedUuidV7<MaskedOrSentinelUuidV7Slug, Case> | UuidSlugError;
153
+ /** Generate the pair through selected sequence state at an explicit time or the current clock. */
154
+ generateUuidV7WithMaskedSlug<Case extends UuidTextCase = typeof UUID_TEXT_LOWERCASE>(this: void, options: GenerateUuidV7WithMaskedSlugOptions<Case>): GeneratedUuidV7<MaskedOrSentinelUuidV7Slug, Case> | UuidSlugError;
155
+ /**
156
+ * Convert UUID text, 16 UUID bytes, a plain slug, or a masked slug to this masking codec's
157
+ * current masked spelling. A 22-character slug is read as masked when it passes this codec's
158
+ * check and as plain otherwise. Other UUID versions
159
+ * return `invalid_uuid_version`. TypeScript rejects known non-v7 values; unbranded external
160
+ * values are validated when called. Timestamps outside the codec's inclusive configured range
161
+ * return `invalid_timestamp`; sentinels are
162
+ * returned as plain slugs without masking and retain the full UUIDv7 timestamp range. A preceding
163
+ * `UuidSlugError` is returned unchanged.
164
+ *
165
+ * @param uuid - Any supported UUIDv7 text, bytes, plain slug, masked slug, or sentinel.
166
+ */
167
+ uuidToMaskedSlug<Input extends UuidInput>(this: void, uuid: UuidV7ValueInput<Input>): MaskedOrSentinelUuidV7Slug | UuidSlugError;
168
+ /**
169
+ * Convert either plain UUIDv7 slug spelling to this codec's current masked or sentinel spelling.
170
+ * TypeScript rejects known UUIDv4 slugs. Other UUIDv4 input returns `invalid_uuid_version`;
171
+ * an out-of-range UUIDv7 returns `invalid_timestamp`; a
172
+ * preceding `UuidSlugError` is returned unchanged.
173
+ *
174
+ * @param plainUuidSlug - Plain UUID slug whose source representation is known by the caller.
175
+ */
176
+ plainToMaskedUuidSlug<Input extends string | UuidSlugError>(this: void, plainUuidSlug: PlainUuidV7SlugInput<Input>): MaskedOrSentinelUuidV7Slug | UuidSlugError;
177
+ /**
178
+ * Convert a masked slug or registered sentinel to a plain UUIDv7 slug. The codec selects the
179
+ * first passing current or previous mask; output defaults to base64url. A preceding
180
+ * `UuidSlugError` is returned unchanged.
181
+ *
182
+ * @param maskedUuidSlug - Masked UUIDv7 slug or registered sentinel.
183
+ * @param alphabet - Plain output spelling. Omit for base64url.
184
+ */
185
+ maskedToPlainUuidSlug<Input extends string | UuidSlugError>(this: void, maskedUuidSlug: SlugStringInput<Input>, alphabet?: SlugAlphabet): PlainUuidV7Slug | UuidSlugError;
186
+ /**
187
+ * Decode the first passing sentinel or mask in configured order to UUIDv7 text in the selected
188
+ * case, lowercase by default.
189
+ * Success proves format integrity, not issuance. TypeScript rejects known UUID text; slug values
190
+ * remain accepted because plain and masked spellings can overlap. A preceding `UuidSlugError`
191
+ * is returned unchanged.
192
+ *
193
+ * @param maskedUuidSlug - Masked UUIDv7 slug or registered sentinel accepted by this masking codec.
194
+ * @param textCase - Built-in UUID text spelling. Omit for lowercase.
195
+ */
196
+ maskedSlugToUuidString<Input extends string | UuidSlugError, Case extends UuidTextCase = typeof UUID_TEXT_LOWERCASE>(this: void, maskedUuidSlug: SlugStringInput<Input>, ...textCase: UuidTextCaseArguments<Case>): UuidV7StringFor<Case> | UuidSlugError;
197
+ /**
198
+ * Decode to a new plain 16-byte `Uint8Array`. Use this when the caller needs binary output. A
199
+ * preceding `UuidSlugError` is returned unchanged.
200
+ *
201
+ * @param maskedUuidSlug - Masked UUIDv7 slug or registered sentinel accepted by this masking codec.
202
+ */
203
+ maskedSlugToUuidBytes<Input extends string | UuidSlugError>(this: void, maskedUuidSlug: SlugStringInput<Input>): UuidV7Bytes | UuidSlugError;
204
+ /**
205
+ * Decode and validate before writing 16 bytes. Return the exact supplied array; errors leave it
206
+ * unchanged. A preceding `UuidSlugError` is returned unchanged without writing.
207
+ *
208
+ * @param maskedUuidSlug - Masked UUIDv7 slug or registered sentinel accepted by this masking codec.
209
+ * @param output - Caller-owned array that receives the 16 UUID bytes.
210
+ * @param outputOffset - Zero-based index where writing starts. Omit to start at index 0. Bytes
211
+ * outside the written range stay unchanged.
212
+ */
213
+ maskedSlugToUuidBytes<Input extends string | UuidSlugError, Output extends Uint8Array>(this: void, maskedUuidSlug: SlugStringInput<Input>, output: Output, outputOffset?: number): UuidOutput<Output> | UuidSlugError;
214
+ /**
215
+ * Decode a masked slug or registered sentinel with this codec and return its UUIDv7 Unix
216
+ * timestamp in milliseconds. Success proves format integrity, not issuance or authorization. A
217
+ * preceding `UuidSlugError` is returned unchanged.
218
+ *
219
+ * @param maskedUuidSlug - Masked slug or registered sentinel accepted by this masking codec.
220
+ */
221
+ extractMaskedUuidV7UnixMs<Input extends string | UuidSlugError>(this: void, maskedUuidSlug: SlugStringInput<Input>): number | UuidSlugError;
222
+ /**
223
+ * Decode with this codec, then interpret the UUIDv7 payload under the layout the caller supplies.
224
+ * The slug cannot identify its generator or layout, so this method never guesses.
225
+ *
226
+ * @param maskedUuidSlug - Masked slug or registered sentinel accepted by this masking codec.
227
+ * @param layout - Known leading fraction and fixed-counter widths.
228
+ * @returns The decoded millisecond timestamp, declared fields, and undeclared low payload bits;
229
+ * or a `UuidSlugError` when the slug, mask match, UUID, or layout is invalid.
230
+ */
231
+ extractMaskedUuidV7Payload<Input extends string | UuidSlugError>(this: void, maskedUuidSlug: SlugStringInput<Input>, layout: UuidV7PayloadLayout): UuidV7Payload | UuidSlugError;
232
+ /**
233
+ * Decode with this codec, check the symmetric timestamp window, and return a canonical slug.
234
+ * Base32hex output is lowercase; case-sensitive base64url is unchanged.
235
+ * This checks clock plausibility, not expiry, authentication, replay, or issuance. TypeScript
236
+ * rejects known UUID text because only this codec can resolve overlapping slug spellings. A
237
+ * preceding `UuidSlugError` is returned unchanged.
238
+ *
239
+ * @param maskedUuidSlug - Masked slug or registered sentinel accepted by this masking codec.
240
+ * @param window - Inclusive maximum distance from an explicit or current reference time.
241
+ */
242
+ validateMaskedUuidV7SlugUnixMs<Input extends string | UuidSlugError>(this: void, maskedUuidSlug: SlugStringInput<Input>, window: UuidV7TimestampWindow): (Input extends PlainUuidSlug | MaskedOrSentinelUuidV7Slug ? Input & MaskedOrSentinelUuidV7Slug : MaskedOrSentinelUuidV7Slug) | UuidSlugError;
243
+ }
244
+ //#endregion
245
+ //# sourceMappingURL=masking-codec-types.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"masking-codec-types.d.ts","names":[],"sources":["../src/masking-codec-types.ts"],"mappings":";;;;;;;iBAyCiB;;;;;;;;WAQN;;;;;;;;WAQA,0BACL,aACA,oBACA,qBACA;;;;;;WAOK,qBAAqB;;;;;;;;;WASrB,qBAAqB;;;;;;;YAQpB,6BACP;;;;;;WAMU,MAAM,aAAa,oBAAoB;WACvC;MAEV;WACU;;;;;;;WAOA,mBAAmB;;;iBAIjB;;WAEN,MAAM,aAAa,oBAAoB;;WAEvC;;;;;;;iBAQM;;WAEN,oBAAoB;;EAE7B,oBAAA,YAEE,UAAU,iCACT,sBAAsB;;EAEzB,UAAU,cAAc,WAAA,YAEtB,MAAM,QACL,iBAAiB,eAAe;;;;;;EAMnC,aAAa,cAAc,WAAW,aAAa,sBAAsB,qBAEvE,YAAA,MAAM,UACH,UAAU,sBAAsB,QAClC,iBAAiB,sBAAsB,QAAQ;;;;;;EAMlD,aAAa,aAAa,sBAAsB,qBAAA,YAE9C,MAAM,YACN,uBACG,UAAU,sBAAsB,QAClC,iBAAiB,YAAY;;;;;;EAMhC,YAAY,cAAc,WAAA,YAExB,MAAM,QACL,gBAAgB,sBAAsB;;EAEzC,YAAY,eAAe,YAAA,YAEzB,MAAM,WACN,QAAQ,QACR,wBACC,WAAW,UAAU;;;;;;EAMxB,YAAA,YAAwB,MAAM,YAAY,qBAAqB,gBAAgB;;EAE/E,YAAY,eAAe,YAAA,YAEzB,MAAM,YACN,oBACA,QAAQ,QACR,wBACC,WAAW,UAAU;;;;;;EAMxB,gBAAgB,cAAc,WAAA,YAE5B,MAAM,OACN,WAAW,eACV,oBAAoB,sBAAsB;;;;;;EAM7C,gBAAA,YAEE,MAAM,YACN,oBACA,WAAW,eACV,oBAAoB;;;;;;;;;EASvB,+BAAA,YAEE,sBACC,gCAAgC;;EAEnC,qCAAqC,gBAAgB,0BAAA,YAEnD,SAAS,sBACR,yBAAyB,uBAAuB,YAAY;;;;;;;;EAQ/D,yBAAA,YAEE,UAAU,iCACT,6BAA6B;;;;;;;;;;;EAWhC,6BAA6B,aAAa,sBAAsB,qBAAA,eAE3D,UAAU,sBAAsB,QAClC,gBAAgB,4BAA4B,QAAQ;;EAEvD,6BAA6B,aAAa,sBAAsB,qBAAA,YAE9D,SAAS,oCAAoC,QAC5C,gBAAgB,4BAA4B,QAAQ;;;;;;;;;;;;;EAavD,iBAAiB,cAAc,WAAA,YAE7B,MAAM,iBAAiB,SACtB,6BAA6B;;;;;;;;;EAShC,sBAAsB,uBAAuB,eAAA,YAE3C,eAAe,qBAAqB,SACnC,6BAA6B;;;;;;;;;EAShC,sBAAsB,uBAAuB,eAAA,YAE3C,gBAAgB,gBAAgB,QAChC,WAAW,eACV,kBAAkB;;;;;;;;;;;EAWrB,uBACE,uBAAuB,eACvB,aAAa,sBAAsB,qBAGnC,YAAA,gBAAgB,gBAAgB,WAC7B,UAAU,sBAAsB,QAClC,gBAAgB,QAAQ;;;;;;;EAO3B,sBAAsB,uBAAuB,eAAA,YAE3C,gBAAgB,gBAAgB,SAC/B,cAAc;;;;;;;;;;EAUjB,sBAAsB,uBAAuB,eAAe,eAAe,YAEzE,YAAA,gBAAgB,gBAAgB,QAChC,QAAQ,QACR,wBACC,WAAW,UAAU;;;;;;;;EAQxB,0BAA0B,uBAAuB,eAAA,YAE/C,gBAAgB,gBAAgB,kBACtB;;;;;;;;;;EAUZ,2BAA2B,uBAAuB,eAAA,YAEhD,gBAAgB,gBAAgB,QAChC,QAAQ,sBACP,gBAAgB;;;;;;;;;;;EAWnB,+BAA+B,uBAAuB,eAAA,YAEpD,gBAAgB,gBAAgB,QAChC,QAAQ,yBAEL,cAAc,gBAAgB,6BAC3B,QAAQ,6BACR,8BACJ"}
@@ -0,0 +1,19 @@
1
+ // SPDX-License-Identifier: Apache-2.0
2
+ // @anizoptera/uuid-slug 0.4.0 | https://github.com/Anizoptera/uuid-slug#readme
3
+ import { UuidSlugError } from "./errors.js";
4
+ import { UuidV7MaskingCodec, UuidV7MaskingCodecOptions } from "./masking-codec-types.js";
5
+ //#region src/masking-codec.d.ts
6
+ /**
7
+ * Build an immutable UUIDv7 masking codec from a private `maskSeed`, or from an explicit `mask` when
8
+ * it is derived elsewhere or needs a label or work factor. It reads the writer first, then
9
+ * `previousMasks` in caller order. Invalid masks, sentinels, options, or callbacks return
10
+ * `UuidSlugError`; no implicit public mask is selected. Masked writers return `invalid_timestamp`
11
+ * outside the configured inclusive timestamp range; registered sentinels remain plain.
12
+ *
13
+ * @param options - The writer mask as `maskSeed` or `mask`, exactly one of the two, plus the
14
+ * optional timestamp range, readers, sentinels, and output spelling.
15
+ * @returns The masking codec, or `UuidSlugError` when its configuration is invalid.
16
+ */
17
+ export declare function createUuidV7MaskingCodec(options: UuidV7MaskingCodecOptions): UuidV7MaskingCodec | UuidSlugError;
18
+ //#endregion
19
+ //# sourceMappingURL=masking-codec.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"masking-codec.d.ts","names":[],"sources":["../src/masking-codec.ts"],"mappings":";;;;;;;;;;;;;;;;wBAmVgB,yBACd,SAAS,4BACR,qBAAqB"}
@@ -0,0 +1,391 @@
1
+ // SPDX-License-Identifier: Apache-2.0
2
+ // @anizoptera/uuid-slug 0.4.0 | https://github.com/Anizoptera/uuid-slug#readme
3
+ import { INVALID_MASK as e, INVALID_OPTIONS as t, INVALID_SENTINEL as n, INVALID_TIMESTAMP as r, INVALID_UUID_VERSION as i, RNG_UNAVAILABLE as a, UuidSlugError as o, checkByteRange as s, exactLocalUuidBytes as c, findUnknownOption as l, isSuccessfulUuidBytes as u, isUint8Array as d, isUuidSlugError as f, normalizeUuidSlugInput as p, stringInput as m } from "./errors.js";
4
+ import { BASE64URL_NAME as h } from "./base64url-name.js";
5
+ import { BASE32HEX_NAME as g } from "./alphabet.js";
6
+ import { readGenerationOptions as _ } from "./generation-options.js";
7
+ import { UUID_TEXT_LOWERCASE as v } from "./types.js";
8
+ import { formatUuidBytesUnchecked as y, isUuidString as b, isUuidV7Bytes as x, resolveUuidTextCase as S, uuidStringToBytes as C } from "./uuid.js";
9
+ import { generateUuidV7BytesWithGenerator as w, readUuidV7Generator as T } from "./v7-generator-input.js";
10
+ import { uuidV7BytesFor as E, uuidV7DefaultPayloadLayout as ee } from "./v7-keyless.js";
11
+ import { isMaskHandle as D } from "./mask-handle.js";
12
+ import { MAX_MASKED_UUID_V7_TIMESTAMP_OFFSET_MS as O, noMaskedSlugMatch as k, ownedUuidV7BytesToMaskedSlug as A, unmaskSlug as j } from "./payload.js";
13
+ import { findSentinel as M } from "./sentinel.js";
14
+ import { createMigration as te } from "./migration.js";
15
+ import { registerMaskingCodec as ne } from "./masking-codec-protocol.js";
16
+ import { deriveUuidV7Mask as N } from "./mask.js";
17
+ import { validateTimestampBytes as re } from "./timestamp.js";
18
+ import { extractUuidV7Payload as ie, extractUuidV7UnixMs as ae, plainSlugToUuidBytes as P, readObjectUuidInput as oe, resolveSlugAlphabet as se, uuidBytesToPlainSlug as F, uuidToBytes as I, uuidToPlainSlug as ce, uuidToString as le } from "./slug.js";
19
+ import { createUuidValue as ue, parseUuidWithCodec as de } from "./uuid-value.js";
20
+ import { generateUuidV7ValueWithGenerator as fe, readUuidV7ValueOptions as L } from "./v7-value-options.js";
21
+ //#region src/masking-codec.ts
22
+ const R = "Each sentinel must have a name and UUIDv7 string.", pe = {
23
+ mask: !0,
24
+ maskedSlugAlphabet: !0,
25
+ maskSeed: !0,
26
+ previousMasks: !0,
27
+ sentinels: !0,
28
+ timestampRangeStartUnixMs: !0
29
+ }, z = {
30
+ at: !0,
31
+ generator: !0
32
+ }, me = {
33
+ mask: !0,
34
+ timestampRangeStartUnixMs: !0
35
+ }, B = {
36
+ name: !0,
37
+ uuid: !0
38
+ }, he = {
39
+ at: !0,
40
+ generator: !0,
41
+ textCase: !0
42
+ };
43
+ function invalidGeneratedUuidV7Bytes(e) {
44
+ return !/* @__PURE__ */ d(e) || e.length !== 16 ? new o(t, `generateUuidV7Bytes must return exactly 16 UUID bytes or UuidSlugError; got ${/* @__PURE__ */ d(e) ? `${e.length} bytes` : typeof e}.`) : new o(i, "generateUuidV7Bytes returned 16 bytes that are not an RFC-variant UUIDv7.");
45
+ }
46
+ const V = Object.freeze([]), H = Object.freeze([]), ge = Object.freeze({
47
+ bySlug: /* @__PURE__ */ new Map(),
48
+ byUuid: /* @__PURE__ */ new Map(),
49
+ encoded: H,
50
+ encodedByFingerprint: void 0,
51
+ sentinels: V
52
+ });
53
+ function maskFromOption(t) {
54
+ return /* @__PURE__ */ f(t) || D(t) ? t : typeof t != "object" || !t ? new o(e, "Pass a mask from deriveUuidV7Mask or mask options containing a private seed.") : N(t);
55
+ }
56
+ const U = 2 ** 48 - 1 - O;
57
+ function timestampRangeStart(e, t) {
58
+ if (e === void 0) return 0;
59
+ if (Number.isSafeInteger(e) && e >= 0 && e <= U) return e;
60
+ let n = typeof e == "number" || e === null ? `${e}` : typeof e;
61
+ return new o(r, `${t} must be an integer from 0 through ${U}; got ${n}.`);
62
+ }
63
+ /*#__NO_SIDE_EFFECTS__*/
64
+ function sentinelFingerprint(e) {
65
+ let t = 2166136261;
66
+ for (let n = 0; n < 16; n += 1) t = Math.imul(t ^ e[n], 16777619);
67
+ return t >>> 0;
68
+ }
69
+ /*#__NO_SIDE_EFFECTS__*/
70
+ function findIndexedByteSentinel(e, t, n) {
71
+ let r = /* @__PURE__ */ sentinelFingerprint(n), i = r & t.mask, a = t.positions[i];
72
+ for (; a !== 0;) {
73
+ if (t.fingerprints[i] === r) {
74
+ let t = e[a], r = 0;
75
+ for (; r < 16 && t.bytes[r] === n[r];) r += 1;
76
+ if (r === 16) return t.slug;
77
+ }
78
+ i = i + 1 & t.mask, a = t.positions[i];
79
+ }
80
+ }
81
+ function createSentinels(e, t) {
82
+ let r = [], a = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Map(), c = [], u = /* @__PURE__ */ new Map();
83
+ for (let d of e) {
84
+ if (typeof d != "object" || !d) return new o(n, R);
85
+ let e = /* @__PURE__ */ m(d.name);
86
+ if (e === void 0) return new o(n, R);
87
+ let f = d.uuid, p = typeof f == "string" ? f : /* @__PURE__ */ m(f);
88
+ if (p === void 0) return new o(n, R);
89
+ let _ = /* @__PURE__ */ l(d, B);
90
+ if (_ !== void 0) return new o(n, `Unknown sentinel option: ${_}.`);
91
+ if (e.length === 0) return new o(n, "Sentinel names must not be empty.");
92
+ if (a.has(e)) return new o(n, `Sentinel name "${e}" must be unique within a UUIDv7 masking codec.`);
93
+ let v = C(p);
94
+ if (v instanceof Error) return v;
95
+ if (!/* @__PURE__ */ x(v)) return new o(i, `Sentinel "${e}" must be a UUIDv7, got ${p}.`);
96
+ let b = /* @__PURE__ */ y(v);
97
+ if (s.has(b)) return new o(n, `Sentinel "${e}" repeats the UUID of an earlier sentinel.`);
98
+ let S = /* @__PURE__ */ F(v, t);
99
+ if (S instanceof Error) return S;
100
+ let w = Object.freeze({
101
+ name: e,
102
+ slug: S,
103
+ uuid: b
104
+ });
105
+ r.push(w), a.add(e), s.set(b, w.slug);
106
+ let T = {
107
+ uuid: w.uuid,
108
+ bytes: v,
109
+ slug: w.slug
110
+ };
111
+ c.push(T), u.set(w.slug, T);
112
+ let E = /* @__PURE__ */ F(v, t === "base64url" ? g : h);
113
+ if (E instanceof Error) return E;
114
+ u.set(E, {
115
+ uuid: w.uuid,
116
+ bytes: v,
117
+ slug: E
118
+ });
119
+ }
120
+ let d;
121
+ if (c.length >= 16) {
122
+ let e = 1;
123
+ for (; e < (c.length - 1) * 2;) e *= 2;
124
+ let t = new Uint32Array(e), n = new Uint32Array(e), r = e - 1;
125
+ for (let e = 1; e < c.length; e += 1) {
126
+ let i = c[e], a = /* @__PURE__ */ sentinelFingerprint(i.bytes), o = a & r;
127
+ for (; n[o] !== 0;) o = o + 1 & r;
128
+ t[o] = a, n[o] = e;
129
+ }
130
+ d = {
131
+ fingerprints: t,
132
+ positions: n,
133
+ mask: r
134
+ };
135
+ }
136
+ return {
137
+ bySlug: u,
138
+ byUuid: s,
139
+ encoded: c,
140
+ encodedByFingerprint: d,
141
+ sentinels: Object.freeze(r)
142
+ };
143
+ }
144
+ function createUuidV7MaskingCodec(t) {
145
+ try {
146
+ return buildUuidSlugCodec(t, E);
147
+ } catch (t) {
148
+ return new o(e, "UUIDv7 masking-codec construction failed.", { cause: t });
149
+ }
150
+ }
151
+ function buildUuidSlugCodec(t, r) {
152
+ let g = typeof t == "object" && !!t && !Array.isArray(t), D = g ? t.mask : void 0, O = g ? t.maskSeed : void 0, N = D != null;
153
+ if (N === (O != null)) return new o(e, N ? "Pass maskSeed for private key material or mask for a derived mask, never both." : "Pass { maskSeed } for private masking or { mask: UUID_V7_TEST_MASK } for public examples.");
154
+ let R = /* @__PURE__ */ l(t, pe);
155
+ if (R !== void 0) return new o(e, `Unknown UUIDv7 masking-codec option: ${R}.`);
156
+ let B = maskFromOption(N ? D : { seed: O });
157
+ if (/* @__PURE__ */ f(B)) return B;
158
+ let H = B, U = timestampRangeStart(t.timestampRangeStartUnixMs, "timestampRangeStartUnixMs");
159
+ if (typeof U != "number") return U;
160
+ let W = U, G = {
161
+ mask: H,
162
+ timestampRangeStartUnixMs: W
163
+ }, K = [], _e = t.previousMasks ?? [];
164
+ if (!Array.isArray(_e)) return new o(e, "previousMasks must be an array of masks, mask options, or retained mask-and-range objects.");
165
+ for (let t of _e) {
166
+ let n = typeof t == "object" && !!t && !/* @__PURE__ */ f(t) && "mask" in t;
167
+ if (n) {
168
+ let n = /* @__PURE__ */ l(t, me);
169
+ if (n !== void 0) return new o(e, `Unknown previous-mask option: ${n}.`);
170
+ }
171
+ let r = maskFromOption(n ? t.mask : t);
172
+ if (/* @__PURE__ */ f(r)) return r;
173
+ let i = timestampRangeStart(n ? t.timestampRangeStartUnixMs : void 0, "previousMasks[].timestampRangeStartUnixMs");
174
+ if (typeof i != "number") return i;
175
+ K.push({
176
+ mask: r,
177
+ timestampRangeStartUnixMs: i
178
+ });
179
+ }
180
+ let q = /* @__PURE__ */ se(t.maskedSlugAlphabet ?? "base64url");
181
+ if (q instanceof Error) return q;
182
+ let J = q.name, Y = t.sentinels ?? V;
183
+ if (!Array.isArray(Y)) return new o(n, "sentinels must be an array of named UUIDv7 values.");
184
+ let X = Y.length === 0 ? ge : createSentinels(Y, J);
185
+ if (X instanceof Error) return X;
186
+ let Z = X, Q = /* @__PURE__ */ new Uint8Array(16);
187
+ function decodeUuid(e) {
188
+ let t;
189
+ if (typeof e == "string") t = e;
190
+ else {
191
+ let n = oe(e);
192
+ if (typeof n != "string") return n;
193
+ t = n;
194
+ }
195
+ let n = M(Z.bySlug, t)?.bytes;
196
+ if (n) return n;
197
+ if (t.length === 26) return P(t);
198
+ if (t.length === 27) return j(t, G, K) ?? /* @__PURE__ */ k();
199
+ if (t.length !== 22) return C(t);
200
+ let r = j(t, G, K);
201
+ if (r !== void 0) return r;
202
+ let i = P(t);
203
+ return i instanceof Error ? /* @__PURE__ */ k() : i;
204
+ }
205
+ function encodeMasked(e, t = !1) {
206
+ if (!/* @__PURE__ */ x(e)) return new o(i, "Masking requires exactly 16 RFC-variant UUIDv7 bytes.");
207
+ if (Z.encodedByFingerprint) {
208
+ let t = Z.encoded[0], n = 0;
209
+ for (; n < 16 && t.bytes[n] === e[n];) n += 1;
210
+ if (n === 16) return t.slug;
211
+ let r = /* @__PURE__ */ findIndexedByteSentinel(Z.encoded, Z.encodedByFingerprint, e);
212
+ if (r) return r;
213
+ } else for (let t of Z.encoded) {
214
+ let n = 0;
215
+ for (; n < 16 && t.bytes[n] === e[n];) n += 1;
216
+ if (n === 16) return t.slug;
217
+ }
218
+ return t ? A(e, H, J, Z.bySlug, W) : (Q.set(e), A(Q, H, J, Z.bySlug, W));
219
+ }
220
+ function uuidToString$1(e, t = v, n) {
221
+ let r;
222
+ if (typeof t == "number") {
223
+ if (/* @__PURE__ */ d(e) || t !== 0) return le(e, t, n);
224
+ r = n ?? "lowercase";
225
+ } else r = t;
226
+ let i = S(r);
227
+ if (i instanceof Error) return i;
228
+ let a = /* @__PURE__ */ c(e);
229
+ if (a) return /* @__PURE__ */ y(a, 0, i);
230
+ if (typeof e == "string") {
231
+ if (e.length === 36) {
232
+ if (i === "lowercase" && b(e)) return e;
233
+ } else {
234
+ let t = M(Z.bySlug, e);
235
+ if (t) return i === "lowercase" ? t.uuid : /* @__PURE__ */ y(t.bytes, 0, i);
236
+ }
237
+ }
238
+ let o = decodeUuid(e);
239
+ return o instanceof Error || o === e && /* @__PURE__ */ f(o) ? o : /* @__PURE__ */ y(o, 0, i);
240
+ }
241
+ function uuidToBytes$1(e, t, n, r = 0) {
242
+ let i = typeof t == "number";
243
+ if (i && (/* @__PURE__ */ d(e) || t !== 0)) return n === void 0 ? I(e, t) : I(e, t, n, r);
244
+ let a = i ? n : t, o = i ? r : n ?? 0, l = a === void 0 ? void 0 : /* @__PURE__ */ s(a, o, 16);
245
+ if (l) return l;
246
+ let u = a, p = /* @__PURE__ */ c(e);
247
+ if (p) return u ? (u.set(p, o), u) : new Uint8Array(p);
248
+ let m = decodeUuid(e);
249
+ return m instanceof Error || m === e && /* @__PURE__ */ f(m) ? m : u ? (u.set(m, o), u) : new Uint8Array(m);
250
+ }
251
+ function uuidToPlainSlug$1(e, t = h, n) {
252
+ let r;
253
+ if (typeof t == "number") {
254
+ if (/* @__PURE__ */ d(e) || t !== 0) return ce(e, t, n);
255
+ r = n ?? "base64url";
256
+ } else r = t;
257
+ let i = /* @__PURE__ */ c(e);
258
+ if (i) return /* @__PURE__ */ F(i, r);
259
+ let a = decodeUuid(e);
260
+ return a instanceof Error || a === e && /* @__PURE__ */ f(a) ? a : /* @__PURE__ */ F(a, r);
261
+ }
262
+ function uuidToMaskedSlug(e) {
263
+ if (typeof e == "string" && (e.length === 36 || e.length === 32)) {
264
+ let t = C(e, Q);
265
+ return t instanceof Error ? t : encodeMasked(Q, !0);
266
+ }
267
+ let t = /* @__PURE__ */ c(e);
268
+ if (t) return encodeMasked(t);
269
+ let n = decodeUuid(e);
270
+ return n instanceof Error || n === e && /* @__PURE__ */ f(n) ? n : encodeMasked(n);
271
+ }
272
+ function plainToMaskedUuidSlug(e) {
273
+ let t = p(e);
274
+ if (typeof t != "string") return t;
275
+ let n = P(t, Q);
276
+ return n instanceof Error ? n : encodeMasked(Q, !0);
277
+ }
278
+ function maskedSlugToUuidString(e, t = v) {
279
+ let n = p(e);
280
+ if (typeof n != "string") return n;
281
+ let r = S(t);
282
+ if (r instanceof Error) return r;
283
+ let i = M(Z.bySlug, n);
284
+ if (i) return r === "lowercase" ? i.uuid : /* @__PURE__ */ y(i.bytes, 0, r);
285
+ let a = j(n, G, K) ?? /* @__PURE__ */ k();
286
+ return a instanceof Error ? a : /* @__PURE__ */ y(a, 0, r);
287
+ }
288
+ function maskedSlugToUuidBytes(e, t, n = 0) {
289
+ let r = p(e);
290
+ if (typeof r != "string") return r;
291
+ let i = t === void 0 ? void 0 : /* @__PURE__ */ s(t, n, 16);
292
+ if (i) return i;
293
+ let a = M(Z.bySlug, r)?.bytes, o = a ?? j(r, G, K) ?? /* @__PURE__ */ k();
294
+ return o instanceof Error ? o : t ? (t.set(o, n), t) : a ? new Uint8Array(a) : o;
295
+ }
296
+ function generateCodecBytesFromValues(e) {
297
+ let t = T(e.generator);
298
+ if (t instanceof Error) return t;
299
+ try {
300
+ let n = t ? w(t, e, !0) : Object.hasOwn(e, "at") ? r({ at: e.at }) : r();
301
+ return !/* @__PURE__ */ d(n) || !/* @__PURE__ */ x(n) ? /* @__PURE__ */ f(n) ? n : invalidGeneratedUuidV7Bytes(n) : n;
302
+ } catch (e) {
303
+ return new o(a, "generateUuidV7Bytes threw while generating UUIDv7 bytes.", { cause: e });
304
+ }
305
+ }
306
+ function generateCodecBytes(e) {
307
+ let t = L(e, z);
308
+ return t instanceof Error ? t : generateCodecBytesFromValues(t);
309
+ }
310
+ function generateMaskedUuidV7Slug(e) {
311
+ let t = generateCodecBytes(e);
312
+ return /* @__PURE__ */ f(t) ? t : encodeMasked(t, !0);
313
+ }
314
+ function maskedToPlainUuidSlug(e, t = h) {
315
+ let n = maskedSlugToUuidBytes(e, Q);
316
+ return /* @__PURE__ */ f(n) ? n : /* @__PURE__ */ F(Q, t);
317
+ }
318
+ function generateUuidV7WithMaskedSlug(e = v) {
319
+ let t = typeof e == "string", n = typeof e == "string" ? { textCase: e } : _(e, he, "masked UUIDv7 pair generation");
320
+ if (n instanceof Error) {
321
+ let r = /* @__PURE__ */ m(e);
322
+ r !== void 0 && (t = !0, n = { textCase: r });
323
+ }
324
+ if (n instanceof Error) return n;
325
+ let r = S(n.textCase ?? "lowercase");
326
+ if (r instanceof Error) return r;
327
+ let i = t ? generateCodecBytes() : generateCodecBytesFromValues(n);
328
+ if (!u(i)) return i;
329
+ let a = /* @__PURE__ */ y(i, 0, r), o = encodeMasked(i, !0);
330
+ return o instanceof Error ? o : {
331
+ uuid: a,
332
+ slug: o
333
+ };
334
+ }
335
+ function extractMaskedUuidV7UnixMs(e) {
336
+ let t = p(e);
337
+ if (typeof t != "string") return t;
338
+ let n = M(Z.bySlug, t)?.bytes ?? j(t, G, K) ?? /* @__PURE__ */ k();
339
+ return n instanceof Error ? n : /* @__PURE__ */ ae(n);
340
+ }
341
+ function extractMaskedUuidV7Payload(e, t) {
342
+ let n = p(e);
343
+ if (typeof n != "string") return n;
344
+ let r = M(Z.bySlug, n)?.bytes ?? j(n, G, K) ?? /* @__PURE__ */ k();
345
+ return r instanceof Error ? r : /* @__PURE__ */ ie(r, t);
346
+ }
347
+ function createUuidSlugMigrationDecoder(e) {
348
+ return te([G, ...K], Z.bySlug, e);
349
+ }
350
+ function validateMaskedUuidV7SlugUnixMs(e, t) {
351
+ let n = p(e);
352
+ if (typeof n != "string") return n;
353
+ let r = M(Z.bySlug, n), i = r?.bytes ?? j(n, G, K) ?? /* @__PURE__ */ k();
354
+ if (i instanceof Error) return i;
355
+ let a = re(i, t);
356
+ return a instanceof Error ? a : r?.slug ?? (n.length === 22 ? n : n.toLowerCase());
357
+ }
358
+ function generateUuidV7Value(e) {
359
+ let t = L(e, z);
360
+ if (t instanceof Error) return t;
361
+ let n = T(t.generator);
362
+ if (n instanceof Error) return n;
363
+ if (n) return fe(n, t, $);
364
+ let r = Object.hasOwn(t, "at") ? E({ at: t.at }) : E();
365
+ return r instanceof Error ? r : ue(r, $, ee());
366
+ }
367
+ let $ = {
368
+ sentinels: Z.sentinels,
369
+ generateUuidV7Value,
370
+ parseUuid: (e) => de(e, $),
371
+ uuidToString: uuidToString$1,
372
+ uuidToBytes: uuidToBytes$1,
373
+ uuidToPlainSlug: uuidToPlainSlug$1,
374
+ createUuidSlugMigrationDecoder,
375
+ generateMaskedUuidV7Slug,
376
+ generateUuidV7WithMaskedSlug,
377
+ uuidToMaskedSlug,
378
+ plainToMaskedUuidSlug,
379
+ maskedToPlainUuidSlug,
380
+ maskedSlugToUuidString,
381
+ maskedSlugToUuidBytes,
382
+ extractMaskedUuidV7UnixMs,
383
+ extractMaskedUuidV7Payload,
384
+ validateMaskedUuidV7SlugUnixMs
385
+ };
386
+ return Object.freeze(ne($));
387
+ }
388
+ //#endregion
389
+ export { createUuidV7MaskingCodec };
390
+
391
+ //# sourceMappingURL=masking-codec.js.map