feat: Reinitialize frontend with SvelteKit and TypeScript

- Delete old Vite+Svelte frontend
- Initialize new SvelteKit project with TypeScript
- Configure Tailwind CSS v4 + DaisyUI
- Implement JWT authentication with auto-refresh
- Create login page with form validation (Zod)
- Add protected route guards
- Update Docker configuration for single-stage build
- Add E2E tests with Playwright (6/11 passing)
- Fix Svelte 5 reactivity with $state() runes

Known issues:
- 5 E2E tests failing (timing/async issues)
- Token refresh implementation needs debugging
- Validation error display timing

frontend/node_modules/arkregex/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 ArkType
+
+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.

frontend/node_modules/arkregex/README.md

@@ -0,0 +1,61 @@
+# arkregex
+
+A drop-in replacement for `new RegExp()` with types
+
+## Usage
+
+The `regex` function creates a `Regex` instance with types for `.test()`, `.exec()` and more, statically parsed from native JS syntax:
+
+```ts
+import { regex } from "arkregex"
+
+const ok = regex("^ok$", "i")
+// Regex<"ok" | "oK" | "Ok" | "OK", { flags: "i" }>
+
+const semver = regex("^(\\d*)\\.(\\d*)\\.(\\d*)$")
+// Regex<`${number}.${number}.${number}`, { captures: [`${number}`, `${number}`, `${number}`] }>
+
+const email = regex("^(?<name>\\w+)@(?<domain>\\w+\\.\\w+)$")
+// Regex<`${string}@${string}.${string}`, { names: { name: string; domain: `${string}.${string}`; }; ...>
+```
+
+All you need to get started is `pnpm install arkregex` (or the equivalent for your package manager of choice) 🎉
+
+Performs best with TS 5.9+
+
+### Features
+
+- **Types**: Infers string types for your existing regular expressions, including positional and named captures
+- **Parity**: Supports 100% of [features](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions) allowed by `new RegExp()`
+- **Safety**: Syntax errors like referencing a group that doesn't exist are now type errors
+- **Zero Runtime**: Improves your type safety without impacting your bundle size
+
+### FAQ
+
+#### Why aren't some patterns like `[a-Z]` inferred more precisely?
+
+Constructing string literal types for these sorts of expressions is combinatorial and will explode very quickly if we infer character ranges like this as literal characters.
+
+We've tried to strike a balance between performance and precision while guaranteeing that the inferred types are at worst imprecise and never incorrect.
+
+#### Why doesn't it work with my massive RegExp?
+
+If your expression is especially long or complex, TypeScript won't be able to infer it.
+
+If your types start to slow down or you see the dreaded `Type is excessively deep...`, you can manually type your expression using `regex.as`:
+
+```ts
+const complexPattern = regex.as<`pattern-${string}`, { captures: [string] }>(
+	"very-long-complex-expression-here"
+)
+```
+
+#### Is it robust?
+
+`arkregex` types are [extensively tested](https://github.com/arktypeio/arktype/tree/main/ark/regex/__tests__/regex.test.ts) and [benchmarked](https://github.com/arktypeio/arktype/tree/main/ark/regex/__tests__/regex.bench.ts) using [attest](https://github.com/arktypeio/arktype/tree/main/ark/attest#readme).
+
+If anything not covered by the other FAQs is not behaving how you'd expect, please don't hesitate to [create an issue](https://github.com/arktypeio/arktype/issues/new).
+
+#### How can I get syntax highlighting for `regex`?
+
+The [ArkType extension](https://marketplace.visualstudio.com/items?itemName=arktypeio.arkdark) can be installed to add syntax highlighting to `regex` calls.

frontend/node_modules/arkregex/out/charset.d.ts

@@ -0,0 +1,15 @@
+import type { Backslash, ErrorMessage, noSuggest, Scanner, writeUnclosedGroupMessage } from "@ark/util";
+import type { parseEscapedChar, StringDigit } from "./escape.ts";
+import type { s, State } from "./state.ts";
+export type parseCharset<s extends State, unscanned extends string> = Scanner.shiftUntilEscapable<unscanned, "]", Backslash> extends (Scanner.shiftResult<infer scanned, infer nextUnscanned>) ? nextUnscanned extends `]${infer remaining}` ? scanned extends Scanner.shift<"^", string> ? s.shiftQuantifiable<s, string, remaining> : parseNonNegatedCharset<scanned, never, null> extends (infer result extends string) ? [
+    result
+] extends [never] ? s.error<emptyCharacterSetMessage> : s.shiftQuantifiable<s, result, remaining> : never : s.error<writeUnclosedGroupMessage<"]">> : never;
+type parseNonNegatedCharset<chars extends string, set extends string, lastChar extends string | null> = parseChar<chars> extends Scanner.shiftResult<infer result, infer unscanned> ? result extends UnescapedDashMarker ? parseDash<unscanned, set, lastChar> : result extends ErrorMessage ? result : parseNonNegatedCharset<unscanned, set | result, result> : set;
+type parseDash<unscanned extends string, set extends string, lastChar extends string | null> = lastChar extends string ? parseChar<unscanned> extends (Scanner.shiftResult<infer rangeEnd, infer next>) ? parseNonNegatedCharset<next, set | inferRange<lastChar, rangeEnd>, null> : // trailing -, treat as literal
+set | "-" : parseNonNegatedCharset<unscanned, set | "-", "-">;
+type inferRange<start extends string, end extends string> = start | end extends StringDigit ? `${number}` : string;
+type UnescapedDashMarker = noSuggest<"dash">;
+type parseChar<unscanned extends string> = unscanned extends Scanner.shift<infer lookahead, infer next> ? lookahead extends Backslash ? next extends Scanner.shift<infer escaped, infer postEscaped> ? Scanner.shiftResult<parseEscapedChar<escaped>, postEscaped> : never : Scanner.shiftResult<lookahead extends "-" ? UnescapedDashMarker : lookahead, next> : null;
+export declare const emptyCharacterSetMessage = "Empty character set [] is unsatisfiable";
+export type emptyCharacterSetMessage = typeof emptyCharacterSetMessage;
+export {};

frontend/node_modules/arkregex/out/charset.js

@@ -0,0 +1 @@
+export const emptyCharacterSetMessage = "Empty character set [] is unsatisfiable";

frontend/node_modules/arkregex/out/escape.d.ts

@@ -0,0 +1,29 @@
+import type { ErrorMessage, Scanner, WhitespaceChar } from "@ark/util";
+import type { Control, ReferenceNode, s, State } from "./state.ts";
+export type parseEscape<s extends State, unscanned extends string> = unscanned extends Scanner.shift<infer char, infer nextUnscanned> ? char extends NonZeroDigit ? parseNumericBackreference<s, unscanned> : char extends "k" ? parseNamedBackreference<s, nextUnscanned> : char extends UnicodePropertyChar ? parseUnicodeProperty<s, char, nextUnscanned> : parseSingleEscapedCharacter<s, char, nextUnscanned> : s.error<trailingBackslashMessage>;
+type parseNumericBackreference<s extends State, fullUnscanned extends string> = Scanner.shiftUntilNot<fullUnscanned, StringDigit> extends (Scanner.shiftResult<infer ref, infer remaining>) ? s.shiftQuantifiable<s, ReferenceNode<ref>, remaining> : never;
+type parseNamedBackreference<s extends State, unscanned extends string> = unscanned extends `<${infer ref}>${infer following}` ? s.shiftQuantifiable<s, ReferenceNode<ref>, following> : s.error<missingBackreferenceNameMessage>;
+type parseUnicodeProperty<s extends State, char extends UnicodePropertyChar, unscanned extends string> = unscanned extends `{${string}}${infer following}` ? s.shiftQuantifiable<s, string, following> : s.error<writeInvalidUnicodePropertyMessage<char>>;
+type parseSingleEscapedCharacter<s extends State, char extends string, remaining extends string> = parseEscapedChar<char> extends infer result extends string ? result extends ErrorMessage ? s.error<result> : s.shiftQuantifiable<s, result, remaining> : never;
+export type parseEscapedChar<char extends string> = char extends RegexClassChar ? string : char extends "d" ? `${number}` : char extends "s" ? WhitespaceChar : char extends BoundaryChar ? "" : char extends Control ? char : char extends "c" ? ErrorMessage<caretNotationMessage> : char extends StringEscapableChar ? ErrorMessage<writeStringEscapableMessage<char>> : ErrorMessage<writeUnnecessaryEscapeMessage<char>>;
+export declare const trailingBackslashMessage = "A regex cannot end with \\";
+export type trailingBackslashMessage = typeof trailingBackslashMessage;
+export declare const writeUnresolvableBackreferenceMessage: <ref extends string | number>(ref: ref) => writeUnresolvableBackreferenceMessage<ref>;
+export type writeUnresolvableBackreferenceMessage<ref extends string | number> = `Group ${ref} does not exist`;
+export declare const missingBackreferenceNameMessage = "\\k must be followed by a named reference like <name>";
+export type missingBackreferenceNameMessage = typeof missingBackreferenceNameMessage;
+export declare const writeInvalidUnicodePropertyMessage: <char extends UnicodePropertyChar>(char: char) => writeInvalidUnicodePropertyMessage<char>;
+export type writeInvalidUnicodePropertyMessage<char extends UnicodePropertyChar> = `\\${char} must be followed by a property like \\${char}{Emoji_Presentation}`;
+export declare const writeUnnecessaryEscapeMessage: <char extends string>(char: char) => writeUnnecessaryEscapeMessage<char>;
+export type writeUnnecessaryEscapeMessage<char extends string> = `Escape preceding ${char} is unnecessary and should be removed.`;
+export declare const writeStringEscapableMessage: (char: StringEscapableChar) => "\\v should be specified with a single backslash like regex('\\n')" | "\\u should be specified with a single backslash like regex('\\n')" | "\\0 should be specified with a single backslash like regex('\\n')" | "\\t should be specified with a single backslash like regex('\\n')" | "\\n should be specified with a single backslash like regex('\\n')" | "\\r should be specified with a single backslash like regex('\\n')" | "\\f should be specified with a single backslash like regex('\\n')" | "\\x should be specified with a single backslash like regex('\\n')";
+export type writeStringEscapableMessage<char extends StringEscapableChar> = `\\${char} should be specified with a single backslash like regex('\n')`;
+export declare const caretNotationMessage = "\\\\cX notation is not supported. Use hex (\\\\x) or unicode (\\\\u) instead.";
+export type caretNotationMessage = "\\cX notation is not supported. Use hex (\\x) or unicode (\\u) instead.";
+export type StringEscapableChar = "t" | "n" | "r" | "f" | "v" | "0" | "x" | "u";
+export type RegexClassChar = "w" | "W" | "D" | "S";
+export type BoundaryChar = "b" | "B";
+export type UnicodePropertyChar = "p" | "P";
+export type NonZeroDigit = "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+export type StringDigit = "0" | NonZeroDigit;
+export {};

frontend/node_modules/arkregex/out/escape.js

@@ -0,0 +1,10 @@
+export const trailingBackslashMessage = "A regex cannot end with \\";
+export const writeUnresolvableBackreferenceMessage = (ref) => `Group ${ref} does not exist`;
+export const missingBackreferenceNameMessage = "\\k must be followed by a named reference like <name>";
+export const writeInvalidUnicodePropertyMessage = (char) => `\\${char} must be followed by a property like \\${char}{Emoji_Presentation}`;
+export const writeUnnecessaryEscapeMessage = (char) => `Escape preceding ${char} is unnecessary and should be removed.`;
+// we have to add extra backslashes to the runtime variants of these
+// so that attest can compare them correctly to their type-level equivalents
+// the runtime variants are only used for the tests
+export const writeStringEscapableMessage = (char) => `\\${char} should be specified with a single backslash like regex('\\n')`;
+export const caretNotationMessage = "\\\\cX notation is not supported. Use hex (\\\\x) or unicode (\\\\u) instead.";

frontend/node_modules/arkregex/out/execArray.d.ts

@@ -0,0 +1,23 @@
+import type { DynamicBase } from "@ark/util";
+import type { Flags, IndexedCaptures, NamedCaptures } from "./regex.ts";
+export interface RegexExecArray<patternAndCaptures extends IndexedCaptures, namedCaptures extends NamedCaptures, flags extends Flags> extends DynamicBase<patternAndCaptures> {
+    /**
+     * The index of the search at which the result was found.
+     */
+    index: number;
+    /**
+     * A copy of the search string.
+     */
+    input: patternAndCaptures[0];
+    indices: flags extends `${string}d${string}` ? RegexIndicesArray<patternAndCaptures, namedCaptures> : undefined;
+    groups: keyof namedCaptures extends never ? undefined : namedCaptures;
+}
+export type RegexIndexRange = [start: number, end: number];
+interface RegexIndicesArray<patternAndCaptures extends IndexedCaptures, namedCaptures extends NamedCaptures> extends DynamicBase<{
+    [i in keyof patternAndCaptures]: RegexIndexRange;
+}> {
+    groups: keyof namedCaptures extends never ? undefined : {
+        [k in keyof namedCaptures]: RegexIndexRange;
+    };
+}
+export {};

frontend/node_modules/arkregex/out/execArray.js

@@ -0,0 +1 @@
+export {};

frontend/node_modules/arkregex/out/group.d.ts

@@ -0,0 +1,33 @@
+import type { ErrorMessage, Scanner, writeUnclosedGroupMessage } from "@ark/util";
+import type { State, s } from "./state.ts";
+type LookaroundChar = "=" | "!";
+export type ModifiableFlag = "i" | "m" | "s";
+export type parseGroup<s extends State, unscanned extends string> = unscanned extends Scanner.shift<infer lookahead, infer next> ? lookahead extends "?" ? parseNonCapturingGroup<s, next> : s.pushGroup<s, State.UnnamedCaptureKind.indexed, unscanned, undefined> : s.error<writeUnclosedGroupMessage<")">>;
+type parseNonCapturingGroup<s extends State, unscanned extends string> = unscanned extends Scanner.shift<infer lookahead, infer next> ? lookahead extends ":" ? s.pushGroup<s, State.UnnamedCaptureKind.noncapturing, next, undefined> : lookahead extends LookaroundChar ? s.pushGroup<s, State.UnnamedCaptureKind.lookaround, next, undefined> : lookahead extends "<" ? parseNamedGroupOrLookbehind<s, next> : shiftModifiers<unscanned> extends (ShiftedModifiers<infer flags, infer negated, infer following>) ? following extends ErrorMessage<infer message> ? s.error<message> : s.pushGroup<s, State.UnnamedCaptureKind.noncapturing, following, "i" extends flags ? true : "i" extends negated ? false : undefined> : never : s.error<writeUnclosedGroupMessage<")">>;
+type ShiftedModifiers<flags extends ModifiableFlag = ModifiableFlag, negated extends ModifiableFlag = ModifiableFlag, unscanned extends string = string> = [ParsedModifiers<flags, negated>, unscanned];
+type ParsedModifiers<flags extends ModifiableFlag = ModifiableFlag, negated extends ModifiableFlag = ModifiableFlag> = {
+    flags: flags;
+    negated: negated;
+};
+type shiftModifiers<unscanned extends string> = Scanner.shiftUntil<unscanned, ":" | ")"> extends (Scanner.shiftResult<infer scanned, infer next>) ? next extends Scanner.shift<infer terminator, infer following> ? terminator extends ":" ? parseModifiers<scanned> extends (ParsedModifiers<infer flags, infer negated>) ? ShiftedModifiers<flags, negated, following> : ShiftedModifiers<never, never, ErrorMessage<parseModifiers<scanned> & string>> : ShiftedModifiers<never, never, ErrorMessage<unescapedLiteralQuestionMarkMessage>> : ShiftedModifiers<never, never, ErrorMessage<writeUnclosedGroupMessage<")">>> : never;
+type parseModifiers<unscanned extends string> = _parseModifiers<unscanned, never, never>;
+type _parseModifiers<unscanned extends string, flags extends ModifiableFlag, negated extends ModifiableFlag> = unscanned extends Scanner.shift<infer lookahead, infer next> ? lookahead extends "-" ? [
+    negated
+] extends [never] ? next extends Scanner.shift<infer modifier, infer next> ? modifier extends ModifiableFlag ? modifier extends flags | negated ? writeDuplicateModifierMessage<modifier> : _parseModifiers<next, flags, negated | modifier> : writeInvalidModifierMessage<modifier> : missingNegatedModifierMessage : multipleModifierDashesMessage : lookahead extends ModifiableFlag ? lookahead extends flags | negated ? writeDuplicateModifierMessage<lookahead> : [
+    negated
+] extends [never] ? _parseModifiers<next, flags | lookahead, negated> : _parseModifiers<next, flags, negated | lookahead> : writeInvalidModifierMessage<lookahead> : ParsedModifiers<flags, negated>;
+export declare const writeDuplicateModifierMessage: <modifier extends ModifiableFlag>(modifier: modifier) => writeDuplicateModifierMessage<modifier>;
+type writeDuplicateModifierMessage<modifier extends ModifiableFlag> = `Modifier ${modifier} cannot appear multiple times in a single group`;
+export declare const multipleModifierDashesMessage = "Modifiers can include at most one '-' to negate subsequent flags";
+type multipleModifierDashesMessage = typeof multipleModifierDashesMessage;
+export declare const missingNegatedModifierMessage = "- must be followed by the modifier flag to negate ('i', 'm' or 's')";
+type missingNegatedModifierMessage = typeof missingNegatedModifierMessage;
+export declare const writeInvalidModifierMessage: <char extends string>(char: char) => writeInvalidModifierMessage<char>;
+type writeInvalidModifierMessage<char extends string> = `Modifier flag ${char} must be 'i', 'm' or 's'`;
+type parseNamedGroupOrLookbehind<s extends State, unscanned extends string> = unscanned extends Scanner.shift<LookaroundChar, infer next> ? s.pushGroup<s, State.UnnamedCaptureKind.lookaround, next, undefined> : shiftNamedGroup<unscanned> extends (Scanner.shiftResult<infer name, infer following>) ? s.pushGroup<s, name, following, undefined> : s.error<writeUnclosedGroupMessage<")">>;
+type shiftNamedGroup<unscanned extends string> = unscanned extends `${infer name}>${infer next}` ? name extends "" ? Scanner.shiftResult<"", ErrorMessage<unnamedCaptureGroupMessage>> : Scanner.shiftResult<name, next> : Scanner.shiftResult<"", ErrorMessage<writeUnclosedGroupMessage<">">>>;
+export declare const unnamedCaptureGroupMessage = "Capture group <> requires a name";
+export type unnamedCaptureGroupMessage = typeof unnamedCaptureGroupMessage;
+export declare const unescapedLiteralQuestionMarkMessage = "literal ? must be escaped at the start of a group";
+export type unescapedLiteralQuestionMarkMessage = typeof unescapedLiteralQuestionMarkMessage;
+export {};

frontend/node_modules/arkregex/out/group.js

@@ -0,0 +1,6 @@
+export const writeDuplicateModifierMessage = (modifier) => `Modifier ${modifier} cannot appear multiple times in a single group`;
+export const multipleModifierDashesMessage = "Modifiers can include at most one '-' to negate subsequent flags";
+export const missingNegatedModifierMessage = `- must be followed by the modifier flag to negate ('i', 'm' or 's')`;
+export const writeInvalidModifierMessage = (char) => `Modifier flag ${char} must be 'i', 'm' or 's'`;
+export const unnamedCaptureGroupMessage = "Capture group <> requires a name";
+export const unescapedLiteralQuestionMarkMessage = "literal ? must be escaped at the start of a group";

frontend/node_modules/arkregex/out/index.d.ts

@@ -0,0 +1 @@
+export { regex, type Regex } from "./regex.ts";

frontend/node_modules/arkregex/out/index.js

@@ -0,0 +1 @@
+export { regex } from "./regex.js";

frontend/node_modules/arkregex/out/parse.d.ts

@@ -0,0 +1,10 @@
+import type { Backslash, ErrorMessage, Scanner } from "@ark/util";
+import type { parseCharset } from "./charset.ts";
+import type { parseEscape } from "./escape.ts";
+import type { parseGroup } from "./group.ts";
+import type { parseBuiltinQuantifier, parsePossibleRange, QuantifyingChar } from "./quantify.ts";
+import type { Anchor, AnchorMarker, s, State, UnionTree } from "./state.ts";
+export type parseState<s extends State> = s["unscanned"] extends ErrorMessage ? s["unscanned"] : s["unscanned"] extends "" ? s.finalize<s> : parseState<next<s>>;
+export type next<s extends State> = s["unscanned"] extends Scanner.shift<infer lookahead, infer unscanned> ? lookahead extends "." ? s.shiftQuantifiable<s, string, unscanned> : lookahead extends Backslash ? parseEscape<s, unscanned> : lookahead extends "|" ? s.finalizeBranch<s, unscanned> : lookahead extends Anchor ? s.anchor<s, AnchorMarker<lookahead>, unscanned> : lookahead extends "(" ? parseGroup<s, unscanned> : lookahead extends ")" ? s.popGroup<s, unscanned> : lookahead extends QuantifyingChar ? parseBuiltinQuantifier<s, lookahead, unscanned> : lookahead extends "{" ? parsePossibleRange<s, unscanned> : lookahead extends "[" ? parseCharset<s, unscanned> : s.shiftQuantifiable<s, maybeSplitCasing<s["caseInsensitive"], lookahead>, unscanned> : never;
+type maybeSplitCasing<caseInsensitive extends boolean, char extends string> = caseInsensitive extends false ? char : Lowercase<char> extends Uppercase<char> ? char : UnionTree<[Lowercase<char>, Capitalize<char>]>;
+export {};

frontend/node_modules/arkregex/out/parse.js

@@ -0,0 +1 @@
+export {};

frontend/node_modules/arkregex/out/quantify.d.ts

@@ -0,0 +1,43 @@
+import type { parseNonNegativeInteger, Scanner } from "@ark/util";
+import type { s, State } from "./state.ts";
+export type parseBuiltinQuantifier<s extends State, quantifier extends QuantifyingChar, unscanned extends string> = s["root"] extends "" ? s.error<writeUnmatchedQuantifierError<quantifier>> : quantifyBuiltin<s, quantifier, unscanned extends Scanner.shift<"?", infer lazyUnscanned> ? lazyUnscanned : unscanned>;
+type quantifyBuiltin<s extends State, quantifier extends QuantifyingChar, unscanned extends string> = quantifier extends "?" ? s.pushQuantifier<s, 0, 1, unscanned> : quantifier extends "+" ? s.pushQuantifier<s, 1, null, unscanned> : quantifier extends "*" ? s.pushQuantifier<s, 0, null, unscanned> : never;
+type ParsedRange = {
+    min: number;
+    max: number | null;
+    unscanned: string;
+};
+declare namespace ParsedRange {
+    type from<r extends ParsedRange> = r;
+}
+type skipPossibleQuestionMark<unscanned extends string> = unscanned extends `?${infer next}` ? next : unscanned;
+type parsePossibleRangeString<unscanned extends string> = unscanned extends (`${infer l extends `${number}`},${infer r extends `${number}`}}${infer next}`) ? ParsedRange.from<{
+    min: parseNonNegativeInteger<l>;
+    max: parseNonNegativeInteger<r>;
+    unscanned: skipPossibleQuestionMark<next>;
+}> : unscanned extends `${infer l extends `${number}`},}${infer next}` ? ParsedRange.from<{
+    min: parseNonNegativeInteger<l>;
+    max: null;
+    unscanned: skipPossibleQuestionMark<next>;
+}> : unscanned extends `${infer l extends `${number}`}}${infer next}` ? ParsedRange.from<{
+    min: parseNonNegativeInteger<l>;
+    max: parseNonNegativeInteger<l>;
+    unscanned: skipPossibleQuestionMark<next>;
+}> : null;
+type parseQuantifier<unscanned extends string, parsed extends ParsedRange> = unscanned extends `${infer range}${parsed["unscanned"]}` ? `{${range}` : never;
+export type parsePossibleRange<s extends State, unscanned extends string, parsed extends ParsedRange | null = parsePossibleRangeString<unscanned>> = parsed extends ParsedRange ? s["root"] extends "" ? s.error<writeUnmatchedQuantifierError<parseQuantifier<unscanned, parsed>>> : [parsed["min"], parsed["max"]] extends ([
+    never,
+    unknown
+] | [unknown, never]) ? s.error<writeUnnaturalNumberQuantifierError<parseQuantifier<unscanned, parsed>>> : s.pushQuantifier<s, parsed["min"], parsed["max"], parsed["unscanned"] extends Scanner.shift<"?", infer lazyUnscanned> ? lazyUnscanned : parsed["unscanned"]> : s.shiftQuantifiable<s, "{", unscanned>;
+export type quantify<pattern extends string, min extends number, max extends number | null> = tryFastPath<pattern, min, max>;
+type tryFastPath<pattern extends string, min extends number, max extends number | null> = max extends 0 ? "" : string extends pattern ? string : `${number}` extends pattern ? `${number}` : min extends 0 ? max extends 1 ? "" | pattern : max extends number ? loopFromZero<pattern, max, "", []> : // max is null, all we can do is append ${string}
+"" | `${pattern}${string}` : loopUntilMin<pattern, min, max, "", []>;
+type loopFromZero<base extends string, max extends number, acc extends string, repetitions extends 1[]> = repetitions["length"] extends max ? acc : loopFromZero<base, max, acc | `${acc}${base}`, [...repetitions, 1]>;
+type loopUntilMin<base extends string, min extends number, max extends number | null, acc extends string, repetitions extends 1[]> = repetitions["length"] extends min ? max extends number ? loopUntilMax<base, min, max, acc, repetitions> : repetitions["length"] extends 0 ? acc | `${acc}${base}${string}` : `${acc}${string}` : loopUntilMin<base, min, max, `${acc}${base}`, [...repetitions, 1]>;
+type loopUntilMax<base extends string, min extends number, max extends number, acc extends string, repetitions extends 1[]> = repetitions["length"] extends max ? acc : loopUntilMax<base, min, max, acc | `${acc}${base}`, [...repetitions, 1]>;
+export type QuantifyingChar = "*" | "+" | "?";
+export declare const writeUnmatchedQuantifierError: <quantifier extends string>(quantifier: quantifier) => writeUnmatchedQuantifierError<quantifier>;
+export type writeUnmatchedQuantifierError<quantifier extends string> = `Quantifier ${quantifier} requires a preceding token`;
+export declare const writeUnnaturalNumberQuantifierError: <quantifier extends string>(quantifier: quantifier) => writeUnnaturalNumberQuantifierError<quantifier>;
+export type writeUnnaturalNumberQuantifierError<quantifier extends string> = `Quantifier ${quantifier} must use natural numbers`;
+export {};

frontend/node_modules/arkregex/out/quantify.js

@@ -0,0 +1,2 @@
+export const writeUnmatchedQuantifierError = (quantifier) => `Quantifier ${quantifier} requires a preceding token`;
+export const writeUnnaturalNumberQuantifierError = (quantifier) => `Quantifier ${quantifier} must use natural numbers`;

frontend/node_modules/arkregex/out/regex.d.ts

@@ -0,0 +1,38 @@
+import type { ErrorMessage, inferred } from "@ark/util";
+import type { RegexExecArray } from "./execArray.ts";
+import type { parseState } from "./parse.ts";
+import type { State } from "./state.ts";
+export type IndexedCaptures = Array<string | undefined>;
+export type NamedCaptures = Record<string, string | undefined>;
+export type UnicodeFlag = "v" | "u";
+export type Flags = `${"d" | ""}${"g" | ""}${"i" | ""}${"m" | ""}${"s" | ""}${UnicodeFlag | ""}${"y" | ""}`;
+export type RegexContext = {
+    flags?: Flags;
+    captures?: IndexedCaptures;
+    names?: NamedCaptures;
+};
+export interface Regex<out pattern extends string = string, out ctx extends RegexContext = RegexContext> extends RegExp {
+    [inferred]: pattern;
+    infer: pattern;
+    inferCaptures: ctx["captures"] extends IndexedCaptures ? ctx["captures"] : [];
+    inferNamedCaptures: ctx["names"] extends NamedCaptures ? ctx["names"] : {};
+    inferExecArray: RegexExecArray<[
+        pattern,
+        ...this["inferCaptures"]
+    ], this["inferNamedCaptures"], this["flags"]>;
+    flags: ctx["flags"] extends Flags ? ctx["flags"] : "";
+    test(s: string): s is pattern;
+    exec(s: string): this["inferExecArray"] | null;
+    exec(s: string): never;
+}
+export interface RegexParser {
+    <src extends string, flags extends Flags = "">(src: regex.validate<src, flags>, flags?: flags): regex.parse<src, flags>;
+    as: <pattern extends string = string, ctx extends RegexContext = {}>(src: string, flags?: Flags) => Regex<pattern, ctx>;
+}
+export declare const regex: RegexParser;
+export type regex<pattern extends string = string, ctx extends RegexContext = RegexContext> = Regex<pattern, ctx>;
+export declare namespace regex {
+    type infer<src extends string, flags extends Flags = ""> = parse<src, flags> extends Regex<infer pattern> ? pattern : never;
+    type validate<src extends string, flags extends Flags = ""> = parse<src, flags> extends infer e extends ErrorMessage ? e : src;
+    type parse<src extends string, flags extends Flags = ""> = parseState<State.initialize<src, flags>>;
+}

frontend/node_modules/arkregex/out/regex.js

@@ -0,0 +1,2 @@
+export const regex = ((src, flags) => new RegExp(src, flags));
+Object.assign(regex, { as: regex });

frontend/node_modules/arkregex/out/state.d.ts

@@ -0,0 +1,359 @@
+import type { contains, ErrorMessage, noSuggest, NumberLiteral, setIndex, unionKeyOf, writeUnclosedGroupMessage, writeUnmatchedGroupCloseMessage, ZeroWidthSpace } from "@ark/util";
+import type { writeUnresolvableBackreferenceMessage } from "./escape.ts";
+import type { quantify, QuantifyingChar } from "./quantify.ts";
+import type { Flags, IndexedCaptures, NamedCaptures, Regex, RegexContext } from "./regex.ts";
+export interface State extends State.Group {
+    unscanned: string;
+    groups: State.Group[];
+    /** the initial flags passed to the root of the expression */
+    flags: Flags;
+}
+export declare namespace State {
+    type from<s extends State> = s;
+    type initialize<source extends string, flags extends Flags> = from<{
+        unscanned: source;
+        groups: [];
+        capture: never;
+        branches: [];
+        sequence: SequenceTree.Empty;
+        root: "";
+        caseInsensitive: contains<flags, "i">;
+        flags: flags;
+    }>;
+    enum UnnamedCaptureKind {
+        indexed,
+        lookaround,
+        noncapturing
+    }
+    type CaptureKind = string | UnnamedCaptureKind;
+    type Group = {
+        /** the name of the group or its kind */
+        capture: CaptureKind;
+        branches: RegexAst[];
+        sequence: RegexAst;
+        root: RegexAst;
+        caseInsensitive: boolean;
+    };
+    namespace Group {
+        type from<g extends Group> = g;
+        type pop<init extends Group, last extends Group[]> = [...last, init];
+        type finalize<g extends Group> = g["branches"] extends [] ? pushQuantifiable<g["sequence"], g["root"]> : [...g["branches"], pushQuantifiable<g["sequence"], g["root"]>] extends (infer branches extends RegexAst[]) ? finalizeUnion<branches, []> : never;
+        type finalizeUnion<remaining extends RegexAst[], flattened extends RegexAst[]> = remaining extends ([
+            infer head extends RegexAst,
+            ...infer tail extends RegexAst[]
+        ]) ? head extends UnionTree<infer headBranches> ? finalizeUnion<tail, [...flattened, ...headBranches]> : finalizeUnion<tail, [...flattened, head]> : UnionTree<flattened>;
+    }
+}
+export type Boundary = Anchor | "(" | ")" | "[" | "]";
+export type Anchor = "^" | "$";
+export type Control = QuantifyingChar | Boundary | "|" | "." | "{" | "-" | "\\";
+export type AnchorMarker<inner extends Anchor = Anchor> = `<${ZeroWidthSpace}${inner}${ZeroWidthSpace}>`;
+export type StartAnchorMarker = AnchorMarker<"^">;
+export type EndAnchorMarker = AnchorMarker<"$">;
+export declare namespace s {
+    type error<message extends string> = State.from<{
+        unscanned: ErrorMessage<message>;
+        groups: [];
+        capture: never;
+        branches: [];
+        sequence: SequenceTree.Empty;
+        root: "";
+        caseInsensitive: false;
+        flags: "";
+    }>;
+    type shiftQuantifiable<s extends State, root extends RegexAst, unscanned extends string> = State.from<{
+        unscanned: unscanned;
+        groups: s["groups"];
+        capture: s["capture"];
+        branches: s["branches"];
+        sequence: pushQuantifiable<s["sequence"], s["root"]>;
+        root: root;
+        caseInsensitive: s["caseInsensitive"];
+        flags: s["flags"];
+    }>;
+    type pushQuantified<s extends State, quantified extends RegexAst, unscanned extends string> = State.from<{
+        unscanned: unscanned;
+        groups: s["groups"];
+        capture: s["capture"];
+        branches: s["branches"];
+        sequence: pushQuantifiable<s["sequence"], quantified>;
+        root: "";
+        caseInsensitive: s["caseInsensitive"];
+        flags: s["flags"];
+    }>;
+    type pushQuantifier<s extends State, min extends number, max extends number | null, unscanned extends string> = State.from<{
+        unscanned: unscanned;
+        groups: s["groups"];
+        capture: s["capture"];
+        branches: s["branches"];
+        sequence: pushQuantifiable<s["sequence"], {
+            kind: "quantifier";
+            ast: s["root"];
+            min: min;
+            max: max;
+        }>;
+        root: "";
+        caseInsensitive: s["caseInsensitive"];
+        flags: s["flags"];
+    }>;
+    type finalizeBranch<s extends State, unscanned extends string> = State.from<{
+        unscanned: unscanned;
+        groups: s["groups"];
+        capture: s["capture"];
+        branches: [...s["branches"], pushQuantifiable<s["sequence"], s["root"]>];
+        sequence: SequenceTree.Empty;
+        root: "";
+        caseInsensitive: s["caseInsensitive"];
+        flags: s["flags"];
+    }>;
+    type anchor<s extends State, a extends AnchorMarker, unscanned extends string> = State.from<{
+        unscanned: unscanned;
+        groups: s["groups"];
+        capture: s["capture"];
+        branches: s["branches"];
+        sequence: pushQuantifiable<s["sequence"], pushQuantifiable<s["root"], a>>;
+        root: "";
+        caseInsensitive: s["caseInsensitive"];
+        flags: s["flags"];
+    }>;
+    type pushGroup<s extends State, capture extends string | State.UnnamedCaptureKind, unscanned extends string, caseInsensitive extends boolean | undefined> = State.from<{
+        unscanned: unscanned;
+        groups: [...s["groups"], s];
+        capture: capture;
+        branches: [];
+        sequence: SequenceTree.Empty;
+        root: "";
+        caseInsensitive: caseInsensitive extends boolean ? caseInsensitive : s["caseInsensitive"];
+        flags: s["flags"];
+    }>;
+    type popGroup<s extends State, unscanned extends string> = s["groups"] extends State.Group.pop<infer last, infer init> ? State.from<{
+        unscanned: unscanned;
+        groups: init;
+        capture: last["capture"];
+        branches: last["branches"];
+        sequence: pushQuantifiable<last["sequence"], last["root"]>;
+        root: s["capture"] extends CapturedGroupKind ? GroupTree<State.Group.finalize<s>, s["capture"]> : s["capture"] extends State.UnnamedCaptureKind.lookaround ? "" : State.Group.finalize<s>;
+        caseInsensitive: last["caseInsensitive"];
+        flags: s["flags"];
+    }> : s.error<writeUnmatchedGroupCloseMessage<")", unscanned>>;
+    type finalize<s extends State> = s["groups"] extends [unknown, ...unknown[]] ? ErrorMessage<writeUnclosedGroupMessage<")">> : finalizeRegexOrError<finalizeTree<State.Group.finalize<s>, {
+        captures: EmptyCaptures;
+        names: {};
+        flags: s["flags"];
+        errors: [];
+    }>>;
+    type finalizeRegexOrError<r extends FinalizationResult> = r["ctx"]["errors"] extends [] ? applyAnchors<r["pattern"]> extends infer pattern extends string ? contains<pattern, StartAnchorMarker> extends false ? contains<pattern, EndAnchorMarker> extends false ? Regex<pattern, finalizeContext<r["ctx"]>> : ErrorMessage<writeMidAnchorError<"$">> : ErrorMessage<writeMidAnchorError<"^">> : never : r["ctx"]["errors"][0];
+    type finalizeContext<ctx extends FinalizationContext> = ctx["captures"] extends EmptyCaptures ? finalizeContextWithoutCaptures<ctx> : finalizeContextWithCaptures<{
+        captures: ctx["captures"] extends ([
+            IndexedCaptureOffset,
+            ...infer rest extends IndexedCaptures
+        ]) ? rest : never;
+        names: ctx["names"];
+        flags: ctx["flags"];
+        errors: ctx["errors"];
+    }>;
+    type finalizeContextWithoutCaptures<ctx extends FinalizationContext> = ctx["flags"] extends "" ? {} : {
+        flags: ctx["flags"];
+    };
+    type finalizeContextWithCaptures<ctx extends FinalizationContext> = keyof ctx["names"] extends never ? ctx["flags"] extends "" ? {
+        captures: ctx["captures"];
+    } : {
+        captures: ctx["captures"];
+        flags: ctx["flags"];
+    } : ctx["flags"] extends "" ? {
+        captures: ctx["captures"];
+        names: ctx["names"];
+    } : {
+        captures: ctx["captures"];
+        names: ctx["names"];
+        flags: ctx["flags"];
+    };
+}
+export type RegexAst = string | ReferenceNode | UnionTree | SequenceTree | GroupTree | QuantifierTree;
+export interface ReferenceNode<to extends string = string> {
+    kind: "reference";
+    to: to;
+}
+export declare namespace ReferenceNode {
+    type finalize<self extends ReferenceNode, ctx extends FinalizationContext, to extends string = self["to"]> = to extends NumberLiteral & keyof ctx["captures"] ? ctx["captures"][to] extends IncompleteCaptureGroup ? FinalizationResult.error<ctx, writeIncompleteReferenceError<to>> : FinalizationResult.from<{
+        pattern: inferReference<ctx["captures"][to]>;
+        ctx: ctx;
+    }> : to extends keyof ctx["names"] ? ctx["names"][to] extends IncompleteCaptureGroup ? FinalizationResult.error<ctx, writeIncompleteReferenceError<to>> : FinalizationResult.from<{
+        pattern: inferReference<ctx["names"][to]>;
+        ctx: ctx;
+    }> : FinalizationResult.error<ctx, writeUnresolvableBackreferenceMessage<to>>;
+    type inferReference<to extends string | undefined> = to extends string ? to : "";
+}
+export declare const writeIncompleteReferenceError: <ref extends string>(ref: ref) => writeIncompleteReferenceError<ref>;
+export type writeIncompleteReferenceError<ref extends string> = `Reference to incomplete group '${ref}' has no effect`;
+export interface SequenceTree<ast extends RegexAst[] = RegexAst[]> {
+    kind: "sequence";
+    ast: ast;
+}
+export declare namespace SequenceTree {
+    type Empty = SequenceTree<[]>;
+    type finalize<self extends SequenceTree, ctx extends FinalizationContext> = _finalize<self["ast"], "", ctx>;
+    type _finalize<tree extends unknown[], pattern extends string, ctx extends FinalizationContext> = tree extends [infer head, ...infer tail] ? finalizeTree<head, ctx> extends infer r ? r extends FinalizationResult ? _finalize<tail, appendNonRedundant<pattern, r["pattern"]>, r["ctx"]> : never : never : FinalizationResult.from<{
+        pattern: pattern;
+        ctx: ctx;
+    }>;
+}
+export interface UnionTree<ast extends RegexAst[] = RegexAst[]> {
+    kind: "union";
+    ast: ast;
+}
+export declare namespace UnionTree {
+    type finalize<self extends UnionTree, ctx extends FinalizationContext> = _finalize<self["ast"], [], ctx>;
+    type FinalizedBranch = {
+        pattern: string;
+        captures: IndexedCaptures;
+        names: NamedCaptures;
+    };
+    namespace FinalizedBranch {
+        type from<b extends FinalizedBranch> = b;
+    }
+    type _finalize<astBranches extends unknown[], acc extends FinalizedBranch[], ctx extends FinalizationContext> = astBranches extends [infer head, ...infer tail] ? finalizeTree<head, ctx> extends infer r ? r extends FinalizationResult ? _finalize<tail, finalizeBranch<acc, ctx, r>, ctx> : never : never : finalizeBranches<keyof acc, acc, ctx>;
+    type finalizeBranch<acc extends FinalizedBranch[], ctx extends FinalizationContext, r extends FinalizationResult> = [
+        ...acc,
+        FinalizedBranch.from<{
+            pattern: r["pattern"];
+            captures: finalizeBranchCaptures<acc, ctx, r>;
+            names: r["ctx"]["names"];
+        }>
+    ];
+    type finalizeBranchCaptures<acc extends FinalizedBranch[], ctx extends FinalizationContext, r extends FinalizationResult, branchCaptures extends IndexedCaptures = extractNewCaptures<ctx["captures"], r["ctx"]["captures"]>> = acc extends [] ? branchCaptures : acc[0]["captures"] extends (infer firstCaptureBranch extends IndexedCaptures) ? branchCaptures extends [] ? {
+        [i in keyof firstCaptureBranch]: undefined;
+    } : [...{
+        [i in keyof firstCaptureBranch]: undefined;
+    }, ...branchCaptures] : never;
+    type finalizeBranches<i, acc extends FinalizedBranch[], ctx extends FinalizationContext> = i extends keyof acc & NumberLiteral ? FinalizationResult.from<{
+        pattern: acc[i]["pattern"];
+        ctx: {
+            flags: ctx["flags"];
+            captures: [...ctx["captures"], ...acc[i]["captures"]];
+            names: {
+                [k in unionKeyOf<acc[number]["names"]>]: k extends (keyof acc[i]["names"]) ? acc[i]["names"][k] : undefined;
+            };
+            errors: ctx["errors"];
+        };
+    }> : never;
+}
+export type CapturedGroupKind = string | State.UnnamedCaptureKind.indexed;
+export type IncompleteCaptureGroup = noSuggest<"incompleteCaptureGroup">;
+export type IndexedCaptureOffset = noSuggest<"indexedCaptureOffset">;
+/**
+ * Offset captures to match 1-based indexing for references
+ * (i.e so that \1 would match the first capture group)
+ */
+export type EmptyCaptures = [IndexedCaptureOffset];
+export interface GroupTree<ast extends RegexAst = RegexAst, capture extends CapturedGroupKind = CapturedGroupKind> {
+    kind: "group";
+    capture: capture;
+    ast: ast;
+}
+export declare namespace GroupTree {
+    type finalize<self extends GroupTree, ctx extends FinalizationContext> = finalizeGroupAst<self, ctx> extends infer r ? r extends FinalizationResult ? finalizeGroupResult<self, ctx, r> : never : never;
+    type finalizeGroupAst<self extends GroupTree, ctx extends FinalizationContext> = finalizeTree<self["ast"], self["capture"] extends string ? {
+        captures: [...ctx["captures"], IncompleteCaptureGroup];
+        names: ctx["names"] & {
+            [_ in self["capture"]]: IncompleteCaptureGroup;
+        };
+        flags: ctx["flags"];
+        errors: ctx["errors"];
+    } : self["capture"] extends State.UnnamedCaptureKind.indexed ? {
+        captures: [...ctx["captures"], IncompleteCaptureGroup];
+        names: ctx["names"];
+        flags: ctx["flags"];
+        errors: ctx["errors"];
+    } : ctx>;
+    type finalizeGroupResult<self extends GroupTree, ctx extends FinalizationContext, r extends FinalizationResult> = FinalizationResult.from<{
+        pattern: r["pattern"];
+        ctx: self["capture"] extends string ? finalizeNamedCapture<self["capture"], ctx["captures"]["length"], r["pattern"], r["ctx"]> : self["capture"] extends State.UnnamedCaptureKind.indexed ? finalizeUnnamedCapture<ctx["captures"]["length"], r["pattern"], r["ctx"]> : r["ctx"];
+    }>;
+    type finalizeNamedCapture<name extends string, index extends number, pattern extends string, ctx extends FinalizationContext> = FinalizationContext.from<{
+        captures: setIndex<ctx["captures"], index, anchorsAway<pattern>>;
+        names: {
+            [k in keyof ctx["names"]]: k extends name ? anchorsAway<pattern> : ctx["names"][k];
+        };
+        flags: ctx["flags"];
+        errors: ctx["errors"];
+    }>;
+    type finalizeUnnamedCapture<index extends number, pattern extends string, ctx extends FinalizationContext> = FinalizationContext.from<{
+        captures: setIndex<ctx["captures"], index, anchorsAway<pattern>>;
+        names: ctx["names"];
+        flags: ctx["flags"];
+        errors: ctx["errors"];
+    }>;
+}
+export interface QuantifierTree<ast extends RegexAst = RegexAst> {
+    kind: "quantifier";
+    ast: ast;
+    min: number;
+    max: number | null;
+}
+export declare namespace QuantifierTree {
+    type finalize<self extends QuantifierTree, ctx extends FinalizationContext> = finalizeTree<self["ast"], ctx> extends infer r extends FinalizationResult ? finalizeQuantifierResult<self, ctx, r> : never;
+    type finalizeQuantifierResult<self extends QuantifierTree, ctx extends FinalizationContext, r extends FinalizationResult, quantifiedCaptures extends IndexedCaptures = extractNewCaptures<ctx["captures"], r["ctx"]["captures"]>> = self["min"] extends 0 ? quantifiedCaptures extends [] ? finalizeNonZeroMinQuantified<self, r> : finalizeZeroMinQuantifiedWithCaptures<self, ctx, r, quantifiedCaptures> : finalizeNonZeroMinQuantified<self, r>;
+    type finalizeNonZeroMinQuantified<self extends QuantifierTree, r extends FinalizationResult> = FinalizationResult.from<{
+        pattern: quantify<r["pattern"], self["min"], self["max"]>;
+        ctx: r["ctx"];
+    }>;
+    type finalizeZeroMinQuantifiedWithCaptures<self extends QuantifierTree, ctx extends FinalizationContext, r extends FinalizationResult, quantifiedCaptures extends IndexedCaptures> = finalizeZeroQuantified<ctx, r, quantifiedCaptures> | finalizeOnePlusQuantified<self["max"], r>;
+    type finalizeZeroQuantified<ctx extends FinalizationContext, r extends FinalizationResult, quantifiedCaptures extends IndexedCaptures> = FinalizationResult.from<{
+        pattern: "";
+        ctx: {
+            captures: [
+                ...ctx["captures"],
+                ...{
+                    [i in keyof quantifiedCaptures]: undefined;
+                }
+            ];
+            flags: r["ctx"]["flags"];
+            names: zeroQuantifiedNames<ctx["names"], r["ctx"]["names"]>;
+            errors: r["ctx"]["errors"];
+        };
+    }>;
+    type zeroQuantifiedNames<base extends NamedCaptures, result extends NamedCaptures> = {
+        [k in keyof result]: k extends keyof base ? result[k] : undefined;
+    } & unknown;
+    type finalizeOnePlusQuantified<max extends number | null, r extends FinalizationResult> = max extends 1 ? r : FinalizationResult.from<{
+        pattern: quantify<r["pattern"], 1, max>;
+        ctx: r["ctx"];
+    }>;
+}
+export type pushQuantifiable<sequence extends RegexAst, root extends RegexAst> = root extends "" ? sequence : sequence extends string ? sequence extends "" ? root : root extends string ? appendNonRedundant<sequence, root> : SequenceTree<[sequence, root]> : sequence extends SequenceTree ? pushToSequence<sequence, root> : SequenceTree<[sequence, root]>;
+type pushToSequence<sequence extends SequenceTree, root extends RegexAst> = sequence extends SequenceTree.Empty ? root : root extends SequenceTree ? SequenceTree<[...sequence["ast"], ...root["ast"]]> : SequenceTree<[...sequence["ast"], root]>;
+type extractNewCaptures<base extends IndexedCaptures, result extends IndexedCaptures> = result extends readonly [...base, ...infer elements extends IndexedCaptures] ? elements : [];
+export interface FinalizationContext extends Required<RegexContext> {
+    errors: ErrorMessage[];
+}
+export declare namespace FinalizationContext {
+    type from<ctx extends FinalizationContext> = ctx;
+}
+export type FinalizationResult = {
+    pattern: string;
+    ctx: FinalizationContext;
+};
+export declare namespace FinalizationResult {
+    type from<r extends FinalizationResult> = r;
+    type error<ctx extends FinalizationContext, message extends string> = from<{
+        pattern: string;
+        ctx: {
+            captures: ctx["captures"];
+            names: ctx["names"];
+            flags: ctx["flags"];
+            errors: [...ctx["errors"], ErrorMessage<message>];
+        };
+    }>;
+}
+export type finalizeTree<tree, ctx extends FinalizationContext> = tree extends string ? FinalizationResult.from<{
+    pattern: tree;
+    ctx: ctx;
+}> : tree extends SequenceTree ? SequenceTree.finalize<tree, ctx> : tree extends UnionTree ? UnionTree.finalize<tree, ctx> : tree extends GroupTree ? GroupTree.finalize<tree, ctx> : tree extends QuantifierTree ? QuantifierTree.finalize<tree, ctx> : tree extends ReferenceNode ? ReferenceNode.finalize<tree, ctx> : never;
+type applyAnchors<pattern extends string> = pattern extends `${StartAnchorMarker}${infer startStripped}` ? startStripped extends `${infer bothStripped}${EndAnchorMarker}` ? bothStripped : appendNonRedundant<startStripped, string> : pattern extends `${infer endStripped}${EndAnchorMarker}` ? prependNonRedundant<endStripped, string> : prependNonRedundant<appendNonRedundant<pattern, string>, string>;
+type anchorsAway<pattern extends string> = pattern extends `${StartAnchorMarker}${infer startStripped}` ? startStripped extends `${infer bothStripped}${EndAnchorMarker}` ? bothStripped : startStripped : pattern extends `${infer endStripped}${EndAnchorMarker}` ? endStripped : pattern;
+type appendNonRedundant<base extends string, suffix extends string> = string extends base ? string extends suffix ? string : `${base}${suffix}` : `${number}` extends base ? `${number}` extends suffix ? `${number}` : `${base}${suffix}` : `${base}${suffix}`;
+type prependNonRedundant<base extends string, prefix extends string> = string extends base ? string extends prefix ? string : `${prefix}${base}` : `${number}` extends base ? `${number}` extends prefix ? `${number}` : `${prefix}${base}` : `${prefix}${base}`;
+export declare const writeMidAnchorError: <anchor extends Anchor>(anchor: anchor) => writeMidAnchorError<anchor>;
+type writeMidAnchorError<anchor extends Anchor> = `Anchor ${anchor} may not appear mid-pattern`;
+export {};

frontend/node_modules/arkregex/out/state.js

@@ -0,0 +1,2 @@
+export const writeIncompleteReferenceError = (ref) => `Reference to incomplete group '${ref}' has no effect`;
+export const writeMidAnchorError = (anchor) => `Anchor ${anchor} may not appear mid-pattern`;

frontend/node_modules/arkregex/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "arkregex",
+  "description": "A drop-in replacement for new RegExp() with types",
+  "version": "0.0.5",
+  "license": "MIT",
+  "author": {
+    "name": "David Blass",
+    "email": "david@arktype.io",
+    "url": "https://arktype.io"
+  },
+  "type": "module",
+  "main": "./out/index.js",
+  "types": "./out/index.d.ts",
+  "exports": {
+    ".": {
+      "ark-ts": "./index.ts",
+      "default": "./out/index.js"
+    },
+    "./internal/*.ts": {
+      "ark-ts": "./*.ts",
+      "default": "./out/*.js"
+    },
+    "./internal/*.js": {
+      "ark-ts": "./*.ts",
+      "default": "./out/*.js"
+    }
+  },
+  "files": [
+    "out"
+  ],
+  "dependencies": {
+    "@ark/util": "0.56.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "ts ../repo/build.ts",
+    "test": "ts ../repo/testPackage.ts",
+    "bench": "ts ./__tests__/regex.bench.ts"
+  }
+}