@velarscript/compiler 0.10.1

package/dist/text-runtime.js

@@ -0,0 +1,285 @@
+export const VELAR_TEXT_METHOD_RUNTIME = String.raw `
+const __velarMaxTextCodeUnits = 16 * 1024 * 1024;
+const __velarMaxTextItems = 1000000;
+const __velarTextNativeArray = globalThis.Array;
+const __velarTextNativeString = globalThis.String;
+const __velarTextNativeNumber = globalThis.Number;
+const __velarTextNativeMath = globalThis.Math;
+const __velarTextNativeObject = globalThis.Object;
+const __velarTextNativeTypeError = globalThis.TypeError;
+const __velarTextNativeRangeError = globalThis.RangeError;
+const __velarTextGetOwnPropertyDescriptor = __velarTextNativeObject.getOwnPropertyDescriptor;
+const __velarTextRuntimeGetPrototypeOf = __velarTextGetOwnPropertyDescriptor(__velarTextNativeObject, "getPrototypeOf")?.value;
+const __velarTextReflectApply = __velarTextGetOwnPropertyDescriptor(globalThis.Reflect, "apply")?.value;
+const __velarTextStringPrototype = __velarTextGetOwnPropertyDescriptor(__velarTextNativeString, "prototype")?.value;
+const __velarTextArrayIsArray = __velarTextGetOwnPropertyDescriptor(__velarTextNativeArray, "isArray")?.value;
+const __velarTextNumberIsSafeInteger = __velarTextGetOwnPropertyDescriptor(__velarTextNativeNumber, "isSafeInteger")?.value;
+const __velarTextNumberIsInteger = __velarTextGetOwnPropertyDescriptor(__velarTextNativeNumber, "isInteger")?.value;
+const __velarTextMathFloor = __velarTextGetOwnPropertyDescriptor(__velarTextNativeMath, "floor")?.value;
+const __velarTextMathMax = __velarTextGetOwnPropertyDescriptor(__velarTextNativeMath, "max")?.value;
+const __velarTextMathMin = __velarTextGetOwnPropertyDescriptor(__velarTextNativeMath, "min")?.value;
+const __velarNativeStringIndexOf = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "indexOf")?.value;
+const __velarNativeStringSlice = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "slice")?.value;
+const __velarNativeStringCharCodeAt = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "charCodeAt")?.value;
+const __velarNativeStringTrim = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "trim")?.value;
+const __velarNativeStringUpper = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "toUpperCase")?.value;
+const __velarNativeStringLower = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "toLowerCase")?.value;
+const __velarNativeStringSplit = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "split")?.value;
+const __velarNativeStringReplace = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "replace")?.value;
+const __velarNativeStringReplaceAll = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "replaceAll")?.value;
+const __velarNativeStringRepeat = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "repeat")?.value;
+const __velarTextSurrogatePattern = /[\u{10000}-\u{10FFFF}\uD800-\uDFFF]/u;
+const __velarTextRegExpPrototype = typeof __velarTextRuntimeGetPrototypeOf === "function" ? __velarTextRuntimeGetPrototypeOf(__velarTextSurrogatePattern) : null;
+const __velarTextSurrogateExec = __velarTextRegExpPrototype ? __velarTextGetOwnPropertyDescriptor(__velarTextRegExpPrototype, "exec")?.value : null;
+function __velarTextCall(operation, receiver, arguments_) {
+  if (typeof operation !== "function" || typeof __velarTextReflectApply !== "function") throw new __velarTextNativeTypeError("The JavaScript text runtime is unavailable");
+  return __velarTextReflectApply(operation, receiver, arguments_);
+}
+
+function __velarTextValue(value) {
+  if (typeof value !== "string") throw new __velarTextNativeTypeError("String methods require a string receiver");
+  if (value.length > __velarMaxTextCodeUnits) throw new __velarTextNativeRangeError("Strings cannot exceed 16 MiB");
+  return value;
+}
+function __velarTextArgument(value, name) {
+  if (typeof value !== "string") throw new __velarTextNativeTypeError(name + " must be a string");
+  if (value.length > __velarMaxTextCodeUnits) throw new __velarTextNativeRangeError(name + " cannot exceed 16 MiB");
+  return value;
+}
+function __velarTextOutput(value, name) {
+  if (value.length > __velarMaxTextCodeUnits) throw new __velarTextNativeRangeError(name + " output cannot exceed 16 MiB");
+  return value;
+}
+function __velarTextCount(value, name) {
+  if (!__velarTextCall(__velarTextNumberIsSafeInteger, __velarTextNativeNumber, [value]) || value < 0 || value > __velarMaxTextCodeUnits) {
+    throw new __velarTextNativeRangeError(name + " must be an integer from 0 through " + __velarMaxTextCodeUnits);
+  }
+  return value;
+}
+function __velarTextList(values, name) {
+  if (values.length > __velarMaxTextItems) throw new __velarTextNativeRangeError(name + " cannot produce more than " + __velarMaxTextItems + " items");
+  return values;
+}
+function __velarTextNextCodePointOffset(value, offset) {
+  const first = __velarTextCall(__velarNativeStringCharCodeAt, value, [offset]);
+  if (first < 0xD800 || first > 0xDBFF || offset + 1 >= value.length) return offset + 1;
+  const second = __velarTextCall(__velarNativeStringCharCodeAt, value, [offset + 1]);
+  return second >= 0xDC00 && second <= 0xDFFF ? offset + 2 : offset + 1;
+}
+function __velarTextCodePointLength(value) {
+  if (__velarTextCall(__velarTextSurrogateExec, __velarTextSurrogatePattern, [value]) === null) return value.length;
+  let length = 0, offset = 0;
+  while (offset < value.length) { offset = __velarTextNextCodePointOffset(value, offset); length += 1; }
+  return length;
+}
+function __velarTextCodePointPrefix(value, count) { return __velarTextCall(__velarNativeStringSlice, value, [0, __velarTextCodeUnitOffset(value, count)]); }
+// A string whose code-point count equals its code-unit count carries no
+// surrogate pair, so a code-point position is already a code-unit offset.
+// The codePointLength argument lets a caller that has already measured the string reuse
+// that measurement; without it the surrogate probe answers the same question
+// in one native scan. Walking code points from zero instead made every offset
+// conversion O(corpus + position), which is what turned slice-based document
+// scanning quadratic.
+function __velarTextOneUnitPerCodePoint(value, codePointLength) {
+  if (codePointLength >= 0) return codePointLength === value.length;
+  return __velarTextCall(__velarTextSurrogateExec, __velarTextSurrogatePattern, [value]) === null;
+}
+function __velarTextCodeUnitOffset(value, position, codePointLength = -1) {
+  if (__velarTextOneUnitPerCodePoint(value, codePointLength)) return position < value.length ? position : value.length;
+  let offset = 0, current = 0;
+  while (offset < value.length && current < position) { offset = __velarTextNextCodePointOffset(value, offset); current += 1; }
+  return offset;
+}
+function __velarTextCodePointIndex(value, unitOffset, codePointLength = -1) {
+  if (__velarTextOneUnitPerCodePoint(value, codePointLength)) return unitOffset <= value.length ? unitOffset : null;
+  let offset = 0, position = 0;
+  while (offset < unitOffset && offset < value.length) { offset = __velarTextNextCodePointOffset(value, offset); position += 1; }
+  return offset === unitOffset ? position : null;
+}
+function __velarTextCodePointDistance(value, start, end) {
+  let offset = start, distance = 0;
+  while (offset < end) { offset = __velarTextNextCodePointOffset(value, offset); distance += 1; }
+  return offset === end ? distance : null;
+}
+function __velarTextReplacementOutputUnits(value, search, replacement, all) {
+  let matches = 0;
+  if (search === "") matches = all ? __velarTextCodePointLength(value) + 1 : 1;
+  else {
+    let cursor = 0;
+    while (true) {
+      const index = __velarTextCall(__velarNativeStringIndexOf, value, [search, cursor]);
+      if (index < 0) break;
+      matches += 1;
+      if (!all) break;
+      cursor = index + search.length;
+    }
+  }
+  if (replacement.length <= search.length || matches === 0) return value.length;
+  const growth = replacement.length - search.length;
+  if (matches > __velarTextCall(__velarTextMathFloor, __velarTextNativeMath, [(__velarMaxTextCodeUnits - value.length) / growth])) return __velarMaxTextCodeUnits + 1;
+  return value.length + matches * growth;
+}
+
+// TXT-D1: ordered string comparison uses code-point order (= UTF-8 binary
+// order). UTF-16 code-unit order already agrees when neither operand
+// contains a surrogate, so the native probe keeps the decoded walk on
+// surrogate-bearing strings only.
+function __velarStringCompare(left, right) {
+  left = __velarTextValue(left);
+  right = __velarTextValue(right);
+  if (left === right) return 0;
+  if (__velarTextCall(__velarTextSurrogateExec, __velarTextSurrogatePattern, [left]) === null
+    && __velarTextCall(__velarTextSurrogateExec, __velarTextSurrogatePattern, [right]) === null) {
+    return left < right ? -1 : 1;
+  }
+  let leftOffset = 0;
+  let rightOffset = 0;
+  while (leftOffset < left.length && rightOffset < right.length) {
+    let first = __velarTextCall(__velarNativeStringCharCodeAt, left, [leftOffset]);
+    let firstUnits = 1;
+    if (first >= 0xD800 && first <= 0xDBFF && leftOffset + 1 < left.length) {
+      const trail = __velarTextCall(__velarNativeStringCharCodeAt, left, [leftOffset + 1]);
+      if (trail >= 0xDC00 && trail <= 0xDFFF) { first = (first - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000; firstUnits = 2; }
+    }
+    let second = __velarTextCall(__velarNativeStringCharCodeAt, right, [rightOffset]);
+    let secondUnits = 1;
+    if (second >= 0xD800 && second <= 0xDBFF && rightOffset + 1 < right.length) {
+      const trail = __velarTextCall(__velarNativeStringCharCodeAt, right, [rightOffset + 1]);
+      if (trail >= 0xDC00 && trail <= 0xDFFF) { second = (second - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000; secondUnits = 2; }
+    }
+    if (first !== second) return first < second ? -1 : 1;
+    leftOffset += firstUnits;
+    rightOffset += secondUnits;
+  }
+  return leftOffset < left.length ? 1 : rightOffset < right.length ? -1 : 0;
+}
+// D41 item 61: two 'Comparable'-bounded values hold numbers or strings, and
+// which one is known only at runtime. A string pair keeps code-point order
+// (TXT-D1); everything else uses the plain relational order, exactly as a
+// monomorphic comparison of that category would.
+function __velarOrderCompare(left, right) {
+  if (typeof left === "string" && typeof right === "string") return __velarStringCompare(left, right);
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function __velarStringSize(value) { return __velarTextCodePointLength(__velarTextValue(value)); }
+function __velarStringTrim(value) { return __velarTextCall(__velarNativeStringTrim, __velarTextValue(value), []); }
+function __velarStringIsBlank(value) { return __velarTextCall(__velarNativeStringTrim, __velarTextValue(value), []) === ""; }
+function __velarStringUpper(value) { return __velarTextOutput(__velarTextCall(__velarNativeStringUpper, __velarTextValue(value), []), "String.upper"); }
+function __velarStringLower(value) { return __velarTextOutput(__velarTextCall(__velarNativeStringLower, __velarTextValue(value), []), "String.lower"); }
+function __velarStringSlice(value, start = 0, end = null) {
+  value = __velarTextValue(value);
+  const total = __velarTextCodePointLength(value);
+  if (end === null) end = total;
+  if (!__velarTextCall(__velarTextNumberIsInteger, __velarTextNativeNumber, [start]) || !__velarTextCall(__velarTextNumberIsInteger, __velarTextNativeNumber, [end])) throw new __velarTextNativeTypeError("String.slice positions must be integers");
+  const first = start < 0 ? __velarTextCall(__velarTextMathMax, __velarTextNativeMath, [total + start, 0]) : __velarTextCall(__velarTextMathMin, __velarTextNativeMath, [start, total]);
+  const last = end < 0 ? __velarTextCall(__velarTextMathMax, __velarTextNativeMath, [total + end, 0]) : __velarTextCall(__velarTextMathMin, __velarTextNativeMath, [end, total]);
+  return __velarTextCall(__velarNativeStringSlice, value, [__velarTextCodeUnitOffset(value, first, total), __velarTextCodeUnitOffset(value, last, total)]);
+}
+function __velarStringChar(value, index) {
+  value = __velarTextValue(value);
+  if (!__velarTextCall(__velarTextNumberIsInteger, __velarTextNativeNumber, [index])) throw new __velarTextNativeTypeError("String.char index must be an integer");
+  const total = __velarTextCodePointLength(value);
+  if (index < 0) index += total;
+  if (index < 0) return null;
+  if (index >= total) return null;
+  const start = __velarTextCodeUnitOffset(value, index, total);
+  return __velarTextCall(__velarNativeStringSlice, value, [start, __velarTextNextCodePointOffset(value, start)]);
+}
+function __velarStringHas(value, text) { return __velarTextCall(__velarNativeStringIndexOf, __velarTextValue(value), [__velarTextArgument(text, "String.has text")]) >= 0; }
+function __velarStringIndex(value, text, start = 0) {
+  value = __velarTextValue(value); text = __velarTextArgument(text, "String.index text");
+  if (!__velarTextCall(__velarTextNumberIsInteger, __velarTextNativeNumber, [start])) throw new __velarTextNativeTypeError("String.index start must be an integer");
+  const total = __velarTextCodePointLength(value);
+  const first = start < 0 ? __velarTextCall(__velarTextMathMax, __velarTextNativeMath, [total + start, 0]) : __velarTextCall(__velarTextMathMin, __velarTextNativeMath, [start, total]);
+  let cursor = __velarTextCodeUnitOffset(value, first, total);
+  if (text === "") return first;
+  while (cursor <= value.length) {
+    const found = __velarTextCall(__velarNativeStringIndexOf, value, [text, cursor]);
+    if (found < 0) return null;
+    const position = __velarTextCodePointIndex(value, found, total);
+    if (position !== null && __velarTextCodePointIndex(value, found + text.length, total) !== null) return position;
+    cursor = found + 1;
+  }
+  return null;
+}
+function __velarStringCount(value, text) {
+  value = __velarTextValue(value); text = __velarTextArgument(text, "String.count text");
+  if (text === "") return __velarTextCodePointLength(value) + 1;
+  let count = 0;
+  let cursor = 0;
+  while (true) {
+    const index = __velarTextCall(__velarNativeStringIndexOf, value, [text, cursor]);
+    if (index < 0) return count;
+    count += 1;
+    cursor = index + text.length;
+  }
+}
+function __velarStringStartsWith(value, text) {
+  value = __velarTextValue(value); text = __velarTextArgument(text, "String.startsWith text");
+  return __velarTextCall(__velarNativeStringIndexOf, value, [text, 0]) === 0;
+}
+function __velarStringEndsWith(value, text) {
+  value = __velarTextValue(value); text = __velarTextArgument(text, "String.endsWith text");
+  const start = value.length - text.length;
+  return start >= 0 && __velarTextCall(__velarNativeStringIndexOf, value, [text, start]) === start;
+}
+function __velarStringSplit(value, separator) {
+  value = __velarTextValue(value); separator = __velarTextArgument(separator, "String.split separator");
+  if (separator === "") {
+    const count = __velarTextCodePointLength(value);
+    if (count > __velarMaxTextItems) throw new __velarTextNativeRangeError("String.split cannot produce more than " + __velarMaxTextItems + " items");
+    const output = new __velarTextNativeArray(count);
+    let offset = 0;
+    for (let index = 0; index < count; index += 1) {
+      const next = __velarTextNextCodePointOffset(value, offset);
+      output[index] = __velarTextCall(__velarNativeStringSlice, value, [offset, next]);
+      offset = next;
+    }
+    return output;
+  }
+  return __velarTextList(__velarTextCall(__velarNativeStringSplit, value, [separator, __velarMaxTextItems + 1]), "String.split");
+}
+function __velarStringReplace(value, from, to) {
+  value = __velarTextValue(value); from = __velarTextArgument(from, "String.replace from"); to = __velarTextArgument(to, "String.replace to");
+  if (__velarTextReplacementOutputUnits(value, from, to, false) > __velarMaxTextCodeUnits) throw new __velarTextNativeRangeError("String.replace output cannot exceed 16 MiB");
+  return __velarTextCall(__velarNativeStringReplace, value, [from, () => to]);
+}
+function __velarStringReplaceAll(value, from, to) {
+  value = __velarTextValue(value); from = __velarTextArgument(from, "String.replaceAll from"); to = __velarTextArgument(to, "String.replaceAll to");
+  if (__velarTextReplacementOutputUnits(value, from, to, true) > __velarMaxTextCodeUnits) throw new __velarTextNativeRangeError("String.replaceAll output cannot exceed 16 MiB");
+  if (from === "") {
+    let output = to;
+    let offset = 0;
+    while (offset < value.length) { const next = __velarTextNextCodePointOffset(value, offset); output += __velarTextCall(__velarNativeStringSlice, value, [offset, next]) + to; offset = next; }
+    return output;
+  }
+  return __velarTextCall(__velarNativeStringReplaceAll, value, [from, () => to]);
+}
+function __velarStringPad(value, size, fill, start) {
+  const name = start ? "String.padStart" : "String.padEnd";
+  value = __velarTextValue(value); size = __velarTextCount(size, name + " size"); fill = __velarTextArgument(fill, name + " fill");
+  const needed = size - __velarTextCodePointLength(value);
+  if (needed <= 0 || fill.length === 0) return value;
+  let outputUnits = value.length;
+  let padding = "";
+  let counted = 0, fillOffset = 0;
+  while (counted < needed) {
+    const next = __velarTextNextCodePointOffset(fill, fillOffset);
+    const character = __velarTextCall(__velarNativeStringSlice, fill, [fillOffset, next]);
+    outputUnits += character.length;
+    if (outputUnits > __velarMaxTextCodeUnits) throw new __velarTextNativeRangeError(name + " output cannot exceed 16 MiB");
+    padding += character;
+    counted += 1;
+    fillOffset = next === fill.length ? 0 : next;
+  }
+  return start ? padding + value : value + padding;
+}
+function __velarStringPadStart(value, size, fill = " ") { return __velarStringPad(value, size, fill, true); }
+function __velarStringPadEnd(value, size, fill = " ") { return __velarStringPad(value, size, fill, false); }
+function __velarStringRepeat(value, count) {
+  value = __velarTextValue(value); count = __velarTextCount(count, "String.repeat count");
+  if (value.length > 0 && count > __velarTextCall(__velarTextMathFloor, __velarTextNativeMath, [__velarMaxTextCodeUnits / value.length])) throw new __velarTextNativeRangeError("String.repeat output cannot exceed 16 MiB");
+  return __velarTextCall(__velarNativeStringRepeat, value, [count]);
+}
+`.trimStart();
+//# sourceMappingURL=text-runtime.js.map

package/dist/text-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-runtime.js","sourceRoot":"","sources":["../src/text-runtime.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,yBAAyB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2RlD,CAAC,SAAS,EAAE,CAAC"}

package/dist/token.d.ts

@@ -0,0 +1,19 @@
+import type { Span } from "./source.ts";
+export type TokenKind = "identifier" | "number" | "string" | "fstring" | "extensionToken" | "unitNumber" | "const" | "let" | "def" | "async" | "await" | "export" | "import" | "js" | "unsafe" | "extern" | "module" | "enum" | "abstract" | "class" | "extends" | "override" | "private" | "static" | "super" | "return" | "throw" | "assert" | "if" | "else" | "for" | "in" | "while" | "break" | "continue" | "try" | "catch" | "finally" | "pass" | "is" | "true" | "false" | "null" | "and" | "or" | "not" | "newline" | "indent" | "dedent" | "leftParen" | "rightParen" | "leftBracket" | "rightBracket" | "leftBrace" | "rightBrace" | "colon" | "comma"
+/** D43 item 67: `@name` marks a name the language owns, not the author. */  | "at" | "dot" | "ellipsis" | "question" | "optionalDot" | "nullish" | "arrow" | "fatArrow" | "pipe" | "amp" | "caret" | "tilde" | "leftShift" | "rightShift" | "unsignedRightShift" | "assign" | "plusAssign" | "minusAssign" | "starAssign" | "slashAssign" | "percentAssign" | "bitOrAssign" | "bitAndAssign" | "bitXorAssign" | "leftShiftAssign" | "rightShiftAssign" | "unsignedRightShiftAssign" | "equal" | "notEqual" | "less" | "lessEqual" | "greater" | "greaterEqual" | "plus" | "minus" | "star" | "starStar" | "slash" | "percent" | "eof";
+export interface Token {
+    readonly kind: TokenKind;
+    readonly value: string;
+    readonly span: Span;
+    readonly payload?: unknown;
+}
+/**
+ * Hard reserved words: spellings the lexer always turns into a keyword token,
+ * so they can never name a binding. D30 item 16 softened the statement-head
+ * words that JavaScript does not reserve — `type`, `match`, `case`, `from`,
+ * `as` — into contextual keywords, which the lexer emits as ordinary
+ * identifiers and the parser recognizes by declaration shape. `enum` stays
+ * here because JavaScript reserves it, and generated JavaScript must be legal.
+ */
+export declare const keywordKinds: Readonly<Record<string, TokenKind>>;
+//# sourceMappingURL=token.d.ts.map

package/dist/token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../src/token.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,SAAS,GACjB,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,gBAAgB,GAChB,YAAY,GACZ,OAAO,GACP,KAAK,GACL,KAAK,GACL,OAAO,GACP,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,IAAI,GACJ,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,UAAU,GACV,OAAO,GACP,SAAS,GACT,UAAU,GACV,SAAS,GACT,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,IAAI,GACJ,MAAM,GACN,KAAK,GACL,IAAI,GACJ,OAAO,GACP,OAAO,GACP,UAAU,GACV,KAAK,GACL,OAAO,GACP,SAAS,GACT,MAAM,GACN,IAAI,GACJ,MAAM,GACN,OAAO,GACP,MAAM,GACN,KAAK,GACL,IAAI,GACJ,KAAK,GACL,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,WAAW,GACX,YAAY,GACZ,aAAa,GACb,cAAc,GACd,WAAW,GACX,YAAY,GACZ,OAAO,GACP,OAAO;AACT,2EAA2E,IAAI,IAAI,GACjF,KAAK,GACL,UAAU,GACV,UAAU,GACV,aAAa,GACb,SAAS,GACT,OAAO,GACP,UAAU,GACV,MAAM,GACN,KAAK,GACL,OAAO,GACP,OAAO,GACP,WAAW,GACX,YAAY,GACZ,oBAAoB,GACpB,QAAQ,GACR,YAAY,GACZ,aAAa,GACb,YAAY,GACZ,aAAa,GACb,eAAe,GACf,aAAa,GACb,cAAc,GACd,cAAc,GACd,iBAAiB,GACjB,kBAAkB,GAClB,0BAA0B,GAC1B,OAAO,GACP,UAAU,GACV,MAAM,GACN,WAAW,GACX,SAAS,GACT,cAAc,GACd,MAAM,GACN,OAAO,GACP,MAAM,GACN,UAAU,GACV,OAAO,GACP,SAAS,GACT,KAAK,CAAC;AAEV,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAyC5D,CAAC"}

package/dist/token.js

@@ -0,0 +1,51 @@
+/**
+ * Hard reserved words: spellings the lexer always turns into a keyword token,
+ * so they can never name a binding. D30 item 16 softened the statement-head
+ * words that JavaScript does not reserve — `type`, `match`, `case`, `from`,
+ * `as` — into contextual keywords, which the lexer emits as ordinary
+ * identifiers and the parser recognizes by declaration shape. `enum` stays
+ * here because JavaScript reserves it, and generated JavaScript must be legal.
+ */
+export const keywordKinds = {
+    const: "const",
+    let: "let",
+    def: "def",
+    async: "async",
+    await: "await",
+    export: "export",
+    import: "import",
+    js: "js",
+    unsafe: "unsafe",
+    extern: "extern",
+    module: "module",
+    enum: "enum",
+    abstract: "abstract",
+    class: "class",
+    extends: "extends",
+    override: "override",
+    private: "private",
+    static: "static",
+    super: "super",
+    return: "return",
+    throw: "throw",
+    assert: "assert",
+    if: "if",
+    else: "else",
+    for: "for",
+    in: "in",
+    while: "while",
+    break: "break",
+    continue: "continue",
+    try: "try",
+    catch: "catch",
+    finally: "finally",
+    pass: "pass",
+    is: "is",
+    true: "true",
+    false: "false",
+    null: "null",
+    and: "and",
+    or: "or",
+    not: "not",
+};
+//# sourceMappingURL=token.js.map

package/dist/token.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.js","sourceRoot":"","sources":["../src/token.ts"],"names":[],"mappings":"AA4GA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,YAAY,GAAwC;IAC/D,KAAK,EAAE,OAAO;IACd,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,EAAE,EAAE,IAAI;IACR,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,UAAU;IACpB,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;IACpB,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,EAAE,EAAE,IAAI;IACR,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,EAAE,EAAE,IAAI;IACR,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,QAAQ,EAAE,UAAU;IACpB,GAAG,EAAE,KAAK;IACV,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;IACZ,EAAE,EAAE,IAAI;IACR,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,EAAE,EAAE,IAAI;IACR,GAAG,EAAE,KAAK;CACX,CAAC"}

package/dist/type-registry-runtime.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Canonical generated runtime for compiler-known Type identities. Core and
+ * extensions embed this source into separate modules, then converge through
+ * one immutable global WeakSet descriptor.
+ */
+export declare const VELAR_TYPE_REGISTRY_RUNTIME: string;
+//# sourceMappingURL=type-registry-runtime.d.ts.map

package/dist/type-registry-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-registry-runtime.d.ts","sourceRoot":"","sources":["../src/type-registry-runtime.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,QA2C3B,CAAC"}

package/dist/type-registry-runtime.js

@@ -0,0 +1,51 @@
+import { VELAR_TYPE_REGISTRY_KEY } from "./runtime-abi.js";
+/**
+ * Canonical generated runtime for compiler-known Type identities. Core and
+ * extensions embed this source into separate modules, then converge through
+ * one immutable global WeakSet descriptor.
+ */
+export const VELAR_TYPE_REGISTRY_RUNTIME = String.raw `
+const __velarTypeNativeWeakSet = globalThis.WeakSet;
+const __velarTypeNativeObject = globalThis.Object;
+const __velarTypeNativeTypeError = globalThis.TypeError;
+const __velarTypeGetOwnPropertyDescriptor = __velarTypeNativeObject.getOwnPropertyDescriptor;
+const __velarTypeDefineProperty = __velarTypeNativeObject.defineProperty;
+const __velarTypeReflectApply = __velarTypeGetOwnPropertyDescriptor(globalThis.Reflect, "apply")?.value;
+const __velarTypeSymbolFor = globalThis.Symbol.for;
+const __velarTypeWeakSetPrototype = __velarTypeGetOwnPropertyDescriptor(__velarTypeNativeWeakSet, "prototype")?.value;
+const __velarTypeWeakSetHas = __velarTypeGetOwnPropertyDescriptor(__velarTypeWeakSetPrototype, "has")?.value;
+const __velarTypeWeakSetAdd = __velarTypeGetOwnPropertyDescriptor(__velarTypeWeakSetPrototype, "add")?.value;
+function __velarTypeCall(operation, receiver, arguments_) { if (typeof operation !== "function" || typeof __velarTypeReflectApply !== "function") throw new __velarTypeNativeTypeError("The JavaScript runtime Type registry API is unavailable"); return __velarTypeReflectApply(operation, receiver, arguments_); }
+const __velarRuntimeTypeRegistryKey = __velarTypeCall(__velarTypeSymbolFor, globalThis.Symbol, [${JSON.stringify(VELAR_TYPE_REGISTRY_KEY)}]);
+const __velarRuntimeTypeRegistry = (() => {
+  const descriptor = __velarTypeGetOwnPropertyDescriptor(globalThis, __velarRuntimeTypeRegistryKey);
+  if (descriptor) {
+    if (!("value" in descriptor) || descriptor.enumerable || descriptor.configurable || descriptor.writable) {
+      throw new __velarTypeNativeTypeError("VelarScript runtime type registry descriptor is invalid");
+    }
+    try { __velarTypeCall(__velarTypeWeakSetHas, descriptor.value, [descriptor.value]); }
+    catch { throw new __velarTypeNativeTypeError("VelarScript runtime type registry is invalid"); }
+    return descriptor.value;
+  }
+  const registry = new __velarTypeNativeWeakSet();
+  __velarTypeCall(__velarTypeDefineProperty, __velarTypeNativeObject, [globalThis, __velarRuntimeTypeRegistryKey, {
+    value: registry,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  }]);
+  return registry;
+})();
+function __velarRegisterRuntimeType(value) {
+  __velarTypeCall(__velarTypeWeakSetAdd, __velarRuntimeTypeRegistry, [value]);
+  return value;
+}
+function __velarRequireRuntimeType(value, name, optional = false) {
+  if (optional && value == null) return null;
+  if (!value || typeof value !== "object" || !__velarTypeCall(__velarTypeWeakSetHas, __velarRuntimeTypeRegistry, [value])) {
+    throw new __velarTypeNativeTypeError(name + " requires a compiler-known VelarScript runtime type");
+  }
+  return value;
+}
+`.trimStart();
+//# sourceMappingURL=type-registry-runtime.js.map

package/dist/type-registry-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-registry-runtime.js","sourceRoot":"","sources":["../src/type-registry-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAE3D;;;;GAIG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;kGAY6C,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BxI,CAAC,SAAS,EAAE,CAAC"}

package/dist/type-validation-runtime.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Canonical generated runtime for data Type traversal. Runtime Type identity
+ * remains owned by type-registry-runtime.ts; this fragment owns only the
+ * per-validation graph state and host operations used by generated validators.
+ */
+export declare const VELAR_TYPE_VALIDATION_RUNTIME: string;
+/** Stateless traversal for collection-shaped runtime Types. */
+export declare const VELAR_RUNTIME_TYPE_COLLECTION_RUNTIME: string;
+export declare const VELAR_VALIDATION_ERROR_RUNTIME: string;
+export declare const VELAR_TYPE_VALIDATION_MODULE = "velar/compiler-runtime-types-v1";
+/**
+ * Project-shared runtime-Type host ABI. Generated predicates and Type values
+ * remain in their source modules; only immutable host operations and fresh
+ * per-call traversal state cross the project boundary.
+ */
+export declare const VELAR_TYPE_VALIDATION_MODULE_SOURCE: string;
+//# sourceMappingURL=type-validation-runtime.d.ts.map

package/dist/type-validation-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-validation-runtime.d.ts","sourceRoot":"","sources":["../src/type-validation-runtime.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,QAgD7B,CAAC;AAEd,+DAA+D;AAC/D,eAAO,MAAM,qCAAqC,QAsCrC,CAAC;AAEd,eAAO,MAAM,8BAA8B,QAc9B,CAAC;AAEd,eAAO,MAAM,4BAA4B,oCAAoC,CAAC;AAE9E;;;;GAIG;AACH,eAAO,MAAM,mCAAmC,QA+BnC,CAAC"}

package/dist/type-validation-runtime.js

@@ -0,0 +1,150 @@
+import { VELAR_COLLECTION_IDENTITY_RUNTIME, VELAR_COLLECTION_TYPE_RUNTIME } from "./collection-runtime.js";
+import { VELAR_TYPE_REGISTRY_RUNTIME } from "./type-registry-runtime.js";
+/**
+ * Canonical generated runtime for data Type traversal. Runtime Type identity
+ * remains owned by type-registry-runtime.ts; this fragment owns only the
+ * per-validation graph state and host operations used by generated validators.
+ */
+export const VELAR_TYPE_VALIDATION_RUNTIME = String.raw `
+const __velarValidationNativeWeakMap = globalThis.WeakMap;
+const __velarValidationNativeSet = globalThis.Set;
+const __velarValidationNativePromise = globalThis.Promise;
+const __velarValidationNativeFunction = globalThis.Function;
+const __velarValidationNativeSymbol = globalThis.Symbol;
+const __velarValidationWeakMapPrototype = __velarCollectionGetOwnPropertyDescriptor(__velarValidationNativeWeakMap, "prototype")?.value;
+const __velarValidationSetPrototype = __velarCollectionGetOwnPropertyDescriptor(__velarValidationNativeSet, "prototype")?.value;
+const __velarValidationFunctionPrototype = __velarCollectionGetOwnPropertyDescriptor(__velarValidationNativeFunction, "prototype")?.value;
+const __velarValidationHasInstanceSymbol = __velarCollectionGetOwnPropertyDescriptor(__velarValidationNativeSymbol, "hasInstance")?.value;
+const __velarValidationWeakMapGetOperation = __velarCollectionGetOwnPropertyDescriptor(__velarValidationWeakMapPrototype, "get")?.value;
+const __velarValidationWeakMapSetOperation = __velarCollectionGetOwnPropertyDescriptor(__velarValidationWeakMapPrototype, "set")?.value;
+const __velarValidationWeakMapDeleteOperation = __velarCollectionGetOwnPropertyDescriptor(__velarValidationWeakMapPrototype, "delete")?.value;
+const __velarValidationSetHasOperation = __velarCollectionGetOwnPropertyDescriptor(__velarValidationSetPrototype, "has")?.value;
+const __velarValidationSetAddOperation = __velarCollectionGetOwnPropertyDescriptor(__velarValidationSetPrototype, "add")?.value;
+const __velarValidationSetDeleteOperation = __velarCollectionGetOwnPropertyDescriptor(__velarValidationSetPrototype, "delete")?.value;
+const __velarValidationSetSizeOperation = __velarCollectionGetOwnPropertyDescriptor(__velarValidationSetPrototype, "size")?.get;
+const __velarValidationFunctionHasInstanceOperation = __velarCollectionGetOwnPropertyDescriptor(__velarValidationFunctionPrototype, __velarValidationHasInstanceSymbol)?.value;
+const __velarValidationFreezeOperation = __velarCollectionGetOwnPropertyDescriptor(__velarCollectionNativeObject, "freeze")?.value;
+function __velarValidationState() { return { active: new __velarValidationNativeWeakMap(), depth: 0 }; }
+function __velarValidationSet() { return new __velarValidationNativeSet(); }
+function __velarValidationWeakMapGet(value, key) { return __velarCollectionHostCall(__velarValidationWeakMapGetOperation, value, [key]); }
+function __velarValidationWeakMapSet(value, key, item) { return __velarCollectionHostCall(__velarValidationWeakMapSetOperation, value, [key, item]); }
+function __velarValidationWeakMapDelete(value, key) { return __velarCollectionHostCall(__velarValidationWeakMapDeleteOperation, value, [key]); }
+function __velarValidationSetHas(value, item) { return __velarCollectionHostCall(__velarValidationSetHasOperation, value, [item]); }
+function __velarValidationSetAdd(value, item) { return __velarCollectionHostCall(__velarValidationSetAddOperation, value, [item]); }
+function __velarValidationSetDelete(value, item) { return __velarCollectionHostCall(__velarValidationSetDeleteOperation, value, [item]); }
+function __velarValidationSetSize(value) { return __velarCollectionHostCall(__velarValidationSetSizeOperation, value, []); }
+function __velarValidationIsArray(value) { return __velarCollectionHostCall(__velarCollectionArrayIsArray, __velarCollectionNativeArray, [value]); }
+function __velarValidationOwnDescriptor(value, key) { return __velarCollectionHostCall(__velarCollectionGetOwnPropertyDescriptor, __velarCollectionNativeObject, [value, key]); }
+function __velarValidationIsInstance(value, constructor) { return __velarCollectionHostCall(__velarValidationFunctionHasInstanceOperation, constructor, [value]); }
+function __velarValidationIsPromise(value) { return __velarValidationIsInstance(value, __velarValidationNativePromise); }
+function __velarValidationFreeze(value) { return __velarCollectionHostCall(__velarValidationFreezeOperation, __velarCollectionNativeObject, [value]); }
+// A record contract accepts only plain data objects: prototype null, or a
+// prototype that itself has none (some realm's Object.prototype). The check
+// is structural rather than an identity comparison so plain values from other
+// realms validate, while class instances, Error values, and host objects are
+// rejected — their prototypes always chain through another object.
+function __velarValidationIsPlainObject(value) {
+  const prototype = __velarCollectionHostCall(__velarCollectionGetPrototypeOf, __velarCollectionNativeObject, [value]);
+  if (prototype === null) return true;
+  return __velarCollectionHostCall(__velarCollectionGetPrototypeOf, __velarCollectionNativeObject, [prototype]) === null;
+}
+// Teaching suffix for record parse failures caused by the plain-object rule.
+function __velarValidationRejectionHint(value) {
+  if (value === null || typeof value !== "object" || __velarValidationIsArray(value) || __velarValidationIsPlainObject(value)) return "";
+  return "; a record accepts only plain data objects — project the fields into a record first, for example {x: instance.x}";
+}
+`.trimStart();
+/** Stateless traversal for collection-shaped runtime Types. */
+export const VELAR_RUNTIME_TYPE_COLLECTION_RUNTIME = String.raw `
+function __velarListTypeIs(value, check) {
+  if (!__velarCollectionHostCall(__velarCollectionArrayIsArray, __velarCollectionNativeArray, [value]) || value.length > 1000000 || __velarCollectionHostCall(__velarCollectionOwnSymbols, __velarCollectionNativeObject, [value]).length > 0 || __velarCollectionHostCall(__velarCollectionOwnNames, __velarCollectionNativeObject, [value]).length !== value.length + 1) return false;
+  const lengthDescriptor = __velarCollectionHostCall(__velarCollectionGetOwnPropertyDescriptor, __velarCollectionNativeObject, [value, "length"]);
+  if (!lengthDescriptor || !lengthDescriptor.writable || lengthDescriptor.enumerable || lengthDescriptor.configurable || !("value" in lengthDescriptor)) return false;
+  for (let index = 0; index < value.length; index += 1) {
+    const descriptor = __velarCollectionHostCall(__velarCollectionGetOwnPropertyDescriptor, __velarCollectionNativeObject, [value, index]);
+    if (!descriptor?.enumerable || !descriptor.configurable || !descriptor.writable || !("value" in descriptor) || !check(descriptor.value)) return false;
+  }
+  return true;
+}
+
+function __velarSetTypeIs(value, check) {
+  if (!__velarIsSet(value) || __velarCollectionHostCall(__velarCollectionSetSize, value, []) > 1000000) return false;
+  const iterator = __velarCollectionSetTypeIterator(value);
+  while (true) { const step = __velarCollectionSetTypeNext(iterator); if (step.done) break; if (!check(step.value)) return false; }
+  return true;
+}
+
+function __velarMapTypeIs(value, check) {
+  if (!__velarIsMap(value) || __velarCollectionHostCall(__velarCollectionMapSize, value, []) > 1000000) return false;
+  const iterator = __velarCollectionMapTypeIterator(value);
+  while (true) { const step = __velarCollectionMapTypeNext(iterator); if (step.done) break; const entry = step.value; if (!check(entry[0], entry[1])) return false; }
+  return true;
+}
+
+function __velarRecordTypeIs(value, check) {
+  if (!__velarIsRecord(value)) return false;
+  const keys = __velarCollectionHostCall(__velarCollectionOwnKeys, __velarCollectionNativeReflect, [value]);
+  if (keys.length > 1000000) return false;
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index];
+    if (typeof key !== "string") return false;
+    const descriptor = __velarCollectionHostCall(__velarCollectionGetOwnPropertyDescriptor, __velarCollectionNativeObject, [value, key]);
+    if (!descriptor?.enumerable || !descriptor.configurable || !descriptor.writable || !("value" in descriptor) || !check(descriptor.value)) return false;
+  }
+  return true;
+}
+`.trimStart();
+export const VELAR_VALIDATION_ERROR_RUNTIME = String.raw `
+const __velarValidationErrorDefineProperty = globalThis.Object.defineProperty;
+class __VelarValidationError extends __velarCollectionNativeTypeError {
+  constructor(message, detail) {
+    super(message);
+    this.name = "ValidationError";
+    this.path = detail?.path ?? null;
+    this.field = detail?.field ?? null;
+    this.reason = detail?.reason ?? null;
+  }
+}
+// D51 rule 107: 'code' answers with the class a value was constructed from, so
+// the compiler-owned class carries the source-level name it reports.
+__velarValidationErrorDefineProperty(__VelarValidationError, "name", { value: "ValidationError", writable: false, enumerable: false, configurable: true });
+`.trimStart();
+export const VELAR_TYPE_VALIDATION_MODULE = "velar/compiler-runtime-types-v1";
+/**
+ * Project-shared runtime-Type host ABI. Generated predicates and Type values
+ * remain in their source modules; only immutable host operations and fresh
+ * per-call traversal state cross the project boundary.
+ */
+export const VELAR_TYPE_VALIDATION_MODULE_SOURCE = String.raw `
+${VELAR_COLLECTION_IDENTITY_RUNTIME}
+${VELAR_COLLECTION_TYPE_RUNTIME}
+${VELAR_TYPE_REGISTRY_RUNTIME}
+${VELAR_TYPE_VALIDATION_RUNTIME}
+${VELAR_RUNTIME_TYPE_COLLECTION_RUNTIME}
+${VELAR_VALIDATION_ERROR_RUNTIME}
+export {
+  __velarRegisterRuntimeType as registerRuntimeType,
+  __velarValidationState as validationState,
+  __velarValidationSet as validationSet,
+  __velarValidationWeakMapGet as validationWeakMapGet,
+  __velarValidationWeakMapSet as validationWeakMapSet,
+  __velarValidationWeakMapDelete as validationWeakMapDelete,
+  __velarValidationSetHas as validationSetHas,
+  __velarValidationSetAdd as validationSetAdd,
+  __velarValidationSetDelete as validationSetDelete,
+  __velarValidationSetSize as validationSetSize,
+  __velarValidationIsArray as validationIsArray,
+  __velarValidationOwnDescriptor as validationOwnDescriptor,
+  __velarValidationIsInstance as validationIsInstance,
+  __velarValidationIsPromise as validationIsPromise,
+  __velarValidationIsPlainObject as validationIsPlainObject,
+  __velarValidationRejectionHint as validationRejectionHint,
+  __velarValidationFreeze as validationFreeze,
+  __velarListTypeIs as listTypeIs,
+  __velarSetTypeIs as setTypeIs,
+  __velarMapTypeIs as mapTypeIs,
+  __velarRecordTypeIs as recordTypeIs,
+  __VelarValidationError as ValidationError,
+};
+`.trimStart();
+//# sourceMappingURL=type-validation-runtime.js.map

package/dist/type-validation-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-validation-runtime.js","sourceRoot":"","sources":["../src/type-validation-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iCAAiC,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AAC3G,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC;AAEzE;;;;GAIG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDtD,CAAC,SAAS,EAAE,CAAC;AAEd,+DAA+D;AAC/D,MAAM,CAAC,MAAM,qCAAqC,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsC9D,CAAC,SAAS,EAAE,CAAC;AAEd,MAAM,CAAC,MAAM,8BAA8B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;CAcvD,CAAC,SAAS,EAAE,CAAC;AAEd,MAAM,CAAC,MAAM,4BAA4B,GAAG,iCAAiC,CAAC;AAE9E;;;;GAIG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,MAAM,CAAC,GAAG,CAAA;EAC3D,iCAAiC;EACjC,6BAA6B;EAC7B,2BAA2B;EAC3B,6BAA6B;EAC7B,qCAAqC;EACrC,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;CAyB/B,CAAC,SAAS,EAAE,CAAC"}