@velarscript/compiler 0.10.3 → 0.11.0

package/dist/collection-lowering-runtime.js

@@ -12,6 +12,8 @@ export const VELAR_COLLECTION_LOWERING_EXPORTS = [
     "__velarReactiveSetIterator",
     "__velarReactiveMapKeyIterator",
     "__velarReactiveRecordIterator",
+    "__velarReactiveMapPairIterator",
+    "__velarReactiveRecordPairIterator",
     "__velarCollectionIterator",
     "__velarCollectionPairIterator",
     "__velarCopyList",
@@ -21,7 +23,14 @@ export const VELAR_COLLECTION_LOWERING_EXPORTS = [
     "__velarCreateSet",
     "__velarCreateMap",
     "__velarCollectionSize",
+    "__velarListSize",
+    "__velarMapSize",
+    "__velarSetSize",
+    "__velarRecordSize",
     "__velarCollectionGet",
+    "__velarListGet",
+    "__velarMapGet",
+    "__velarRecordGet",
     "__velarCollectionSlice",
     // COL-U5: `IndexError` is a nameable source type, so a project build must be
     // able to import the one runtime class every List position raises. The
@@ -30,8 +39,12 @@ export const VELAR_COLLECTION_LOWERING_EXPORTS = [
     // unbound reference.
     "__VelarIndexError",
     "__velarIndex",
+    "__velarListIndexGet",
+    "__velarRecordIndexGet",
     "__velarOptionalIndex",
     "__velarSetIndex",
+    "__velarListIndexSet",
+    "__velarRecordIndexSet",
     "__velarListAppend",
     "__velarListExtend",
     "__velarListInsert",
@@ -67,12 +80,34 @@ export const VELAR_COLLECTION_LOWERING_EXPORTS = [
     "__velarRecordSet",
     "__velarRecordCopy",
     "__velarCollectionHas",
+    "__velarListHas",
+    "__velarMapHas",
+    "__velarSetHas",
+    "__velarRecordHas",
+    "__velarListContains",
+    "__velarMapContains",
+    "__velarSetContains",
+    "__velarRecordContains",
     "__velarContains",
     "__velarCollectionRemove",
+    "__velarMapRemove",
+    "__velarSetRemove",
+    "__velarRecordRemove",
     "__velarCollectionClear",
+    "__velarListClear",
+    "__velarMapClear",
+    "__velarSetClear",
+    "__velarRecordClear",
     "__velarCollectionKeys",
+    "__velarMapKeys",
+    "__velarRecordKeys",
     "__velarCollectionValues",
+    "__velarMapValues",
+    "__velarSetValues",
+    "__velarRecordValues",
     "__velarCollectionEntries",
+    "__velarMapEntries",
+    "__velarRecordEntries",
     "__velarOptionalCollection",
 ];
 export const VELAR_COLLECTION_LOWERING_DEPENDENCIES = [
@@ -208,41 +243,54 @@ function __velarCollectionIterator(value) {
   if (__velarIsRecord(value)) return __velarReactiveRecordIterator(value);
   throw new __velarCollectionNativeTypeError("VelarScript iteration requires a List, Set, Map, or Record");
 }
-function* __velarCollectionPairIterator(value) {
+function* __velarReactiveMapPairIterator(value) {
   const raw = __velarReactiveRaw(value);
-  if (__velarIsMap(raw)) {
-    if (__velarCollectionSetMapMapSize(raw) > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Map cannot exceed 1000000 entries");
-    __velarReactiveCollectionTrack(raw);
-    const iterator = __velarCollectionSetMapMapEntries(raw);
-    while (true) { const step = __velarCollectionSetMapMapNext(iterator); if (step.done) return; const entry = step.value; yield [__velarReactiveCollectionRead(raw, __velarReactiveIterateKey, entry[0]), __velarReactiveCollectionRead(raw, entry[0], entry[1])]; }
-  }
-  if (__velarIsRecord(raw)) {
-    const fields = __velarRecordFields(raw, "Record iteration");
-    __velarReactiveCollectionTrack(raw);
-    for (let index = 0; index < fields.length; index += 1) {
-      const field = fields[index];
-      const descriptor = __velarCollectionRecordGetOwnPropertyDescriptor(raw, field);
-      // COL-D1: the key snapshot can outlive the field — a body that removes
-      // a later key must see that key skipped (Map iteration parity), not a
-      // raw TypeError from reading a missing descriptor.
-      if (descriptor === undefined) continue;
-      yield [__velarReactiveCollectionRead(raw, __velarReactiveIterateKey, field), __velarReactiveCollectionRead(raw, field, descriptor.value)];
-    }
-    return;
+  if (__velarCheckedMapSize(raw, "Map iteration") > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Map cannot exceed 1000000 entries");
+  __velarReactiveCollectionTrack(raw);
+  const iterator = __velarCollectionSetMapMapEntries(raw);
+  while (true) { const step = __velarCollectionSetMapMapNext(iterator); if (step.done) return; const entry = step.value; yield [__velarReactiveCollectionRead(raw, __velarReactiveIterateKey, entry[0]), __velarReactiveCollectionRead(raw, entry[0], entry[1])]; }
+}
+function* __velarReactiveRecordPairIterator(value) {
+  const raw = __velarReactiveRaw(value);
+  const fields = __velarRecordFields(raw, "Record iteration");
+  __velarReactiveCollectionTrack(raw);
+  for (let index = 0; index < fields.length; index += 1) {
+    const field = fields[index];
+    const descriptor = __velarCollectionRecordGetOwnPropertyDescriptor(raw, field);
+    // COL-D1: the key snapshot can outlive the field — a body that removes
+    // a later key must see that key skipped (Map iteration parity), not a
+    // raw TypeError from reading a missing descriptor.
+    if (descriptor === undefined) continue;
+    yield [__velarReactiveCollectionRead(raw, __velarReactiveIterateKey, field), __velarReactiveCollectionRead(raw, field, descriptor.value)];
   }
+}
+function* __velarCollectionPairIterator(value) {
+  const raw = __velarReactiveRaw(value);
+  if (__velarIsMap(raw)) { yield* __velarReactiveMapPairIterator(raw); return; }
+  if (__velarIsRecord(raw)) { yield* __velarReactiveRecordPairIterator(raw); return; }
   let index = 0;
   for (const item of __velarCollectionIterator(value)) yield [item, index++];
 }
 
+function __velarCheckedMapSize(value, name) {
+  try { return __velarCollectionSetMapMapSize(value); }
+  catch { throw new __velarCollectionNativeTypeError(name + " requires a Map"); }
+}
+function __velarCheckedSetSize(value, name) {
+  try { return __velarCollectionSetMapSetSize(value); }
+  catch { throw new __velarCollectionNativeTypeError(name + " requires a Set"); }
+}
+function __velarListSize(value) { value = __velarValidateOwnedList(value, "List size"); __velarReactiveCollectionTrack(value, __velarReactiveStructureKey); return value.length; }
+function __velarMapSize(value) { value = __velarReactiveRaw(value); __velarReactiveCollectionTrack(value, __velarReactiveStructureKey); const size = __velarCheckedMapSize(value, "Map.size"); if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Map cannot exceed 1000000 entries"); return size; }
+function __velarSetSize(value) { value = __velarReactiveRaw(value); __velarReactiveCollectionTrack(value, __velarReactiveStructureKey); const size = __velarCheckedSetSize(value, "Set.size"); if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Set cannot exceed 1000000 items"); return size; }
+function __velarRecordSize(value) { value = __velarReactiveRaw(value); __velarReactiveCollectionTrack(value, __velarReactiveStructureKey); return __velarRecordFields(value, "Record size").length; }
 function __velarCollectionSize(value) {
-  value = __velarReactiveRaw(value);
-  __velarReactiveCollectionTrack(value, __velarReactiveStructureKey);
-  if (__velarCollectionListIsArray(value)) return __velarValidateOwnedList(value, "List size").length;
-  if (__velarIsRecord(value)) return __velarRecordFields(value, "Record size").length;
-  const size = __velarIsMap(value) ? __velarCollectionSetMapMapSize(value) : __velarIsSet(value) ? __velarCollectionSetMapSetSize(value) : null;
-  if (size === null) throw new __velarCollectionNativeTypeError("VelarScript size requires a List, Set, Map, or Record");
-  if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A collection cannot exceed 1000000 items");
-  return size;
+  const raw = __velarReactiveRaw(value);
+  if (__velarCollectionListIsArray(raw)) return __velarListSize(raw);
+  if (__velarIsRecord(raw)) return __velarRecordSize(raw);
+  if (__velarIsMap(raw)) return __velarMapSize(raw);
+  if (__velarIsSet(raw)) return __velarSetSize(raw);
+  throw new __velarCollectionNativeTypeError("VelarScript size requires a List, Set, Map, or Record");
 }
 
 function __velarCreateList(parts) {
@@ -329,32 +377,38 @@ function __velarCreateMap(value) {
   throw new __velarCollectionNativeTypeError("Map construction requires a Map, a List of [key, value] Lists, or a record");
 }
 
-function __velarCollectionGet(value, key) {
+function __velarListGet(value, key) {
+  value = __velarValidateOwnedList(value, "List.get");
+  if (!__velarCollectionListIsInteger(key)) throw new __VelarIndexError("List.get index must be an integer");
+  const index = key < 0 ? value.length + key : key;
+  if (index >= 0 && index < value.length) return __velarReactiveCollectionRead(value, index, __velarOwnedListElement(value, index, "List.get"));
+  __velarReactiveCollectionTrack(value, key < 0 ? __velarReactiveIterateKey : index);
+  __velarReactiveCollectionTrack(value);
+  return null;
+}
+function __velarRecordGet(value, key) {
   value = __velarReactiveRaw(value);
-  if (__velarCollectionListIsArray(value)) {
-    __velarValidateOwnedList(value, "List.get");
-    if (!__velarCollectionListIsInteger(key)) throw new __VelarIndexError("List.get index must be an integer");
-    const index = key < 0 ? value.length + key : key;
-    if (index >= 0 && index < value.length) return __velarReactiveCollectionRead(value, index, __velarOwnedListElement(value, index, "List.get"));
-    __velarReactiveCollectionTrack(value, key < 0 ? __velarReactiveIterateKey : index);
-    __velarReactiveCollectionTrack(value);
-    return null;
-  }
-  if (__velarIsRecord(value)) {
-    if (typeof key !== "string") throw new __velarCollectionNativeTypeError("Record.get requires a string key");
-    __velarRecordFields(value, "Record.get");
-    __velarReactiveCollectionTrack(value, key);
-    const descriptor = __velarCollectionRecordGetOwnPropertyDescriptor(value, key);
-    return descriptor === undefined ? null : __velarReactiveCollectionRead(value, key, descriptor.value);
-  }
-  if (!__velarIsMap(value)) throw new __velarCollectionNativeTypeError("Map.get requires a Map");
-  const size = __velarCollectionSetMapMapSize(value);
+  if (typeof key !== "string") throw new __velarCollectionNativeTypeError("Record.get requires a string key");
+  __velarRecordFields(value, "Record.get");
+  __velarReactiveCollectionTrack(value, key);
+  const descriptor = __velarCollectionRecordGetOwnPropertyDescriptor(value, key);
+  return descriptor === undefined ? null : __velarReactiveCollectionRead(value, key, descriptor.value);
+}
+function __velarMapGet(value, key) {
+  value = __velarReactiveRaw(value);
+  const size = __velarCheckedMapSize(value, "Map.get");
   if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Map cannot exceed 1000000 entries");
   key = __velarReactiveRaw(key);
   __velarReactiveCollectionTrack(value, key);
   const item = __velarCollectionSetMapMapGet(value, key);
   return item === undefined ? null : __velarReactiveCollectionRead(value, key, item);
 }
+function __velarCollectionGet(value, key) {
+  const raw = __velarReactiveRaw(value);
+  if (__velarCollectionListIsArray(raw)) return __velarListGet(raw, key);
+  if (__velarIsRecord(raw)) return __velarRecordGet(raw, key);
+  return __velarMapGet(raw, key);
+}
 
 function __velarCollectionSlice(value, start = 0, end = null) {
   value = __velarValidateOwnedList(value, "List.slice");
@@ -387,37 +441,41 @@ function __velarStrictListIndex(value, requested) {
   if (index < 0 || index >= value.length) throw new __VelarIndexError("List index must be an in-range integer");
   return index;
 }
-function __velarIndex(value, index) {
+function __velarListIndexGet(value, index) {
+  value = __velarValidateOwnedList(value, "List index");
+  index = __velarStrictListIndex(value, index);
+  return __velarReactiveCollectionRead(value, index, __velarOwnedListElement(value, index, "List index"));
+}
+function __velarRecordIndexGet(value, index) {
   value = __velarReactiveRaw(value);
-  if (__velarCollectionListIsArray(value)) {
-    __velarValidateOwnedList(value, "List index");
-    index = __velarStrictListIndex(value, index);
-    return __velarReactiveCollectionRead(value, index, __velarOwnedListElement(value, index, "List index"));
-  }
-  if (!__velarIsRecord(value) || typeof index !== "string") throw new __velarCollectionNativeTypeError("Record index requires a plain record and a string key");
+  if (typeof index !== "string") throw new __velarCollectionNativeTypeError("Record index requires a plain record and a string key");
   __velarRecordFields(value, "Record index");
   const descriptor = __velarCollectionRecordGetOwnPropertyDescriptor(value, index);
   return __velarReactiveCollectionRead(value, index, descriptor?.value);
 }
+function __velarIndex(value, index) {
+  const raw = __velarReactiveRaw(value);
+  return __velarCollectionListIsArray(raw) ? __velarListIndexGet(raw, index) : __velarRecordIndexGet(raw, index);
+}
 function __velarOptionalIndex(value, index) {
   return value == null ? null : __velarIndex(value, index());
 }
-function __velarSetIndex(value, index, next) {
+function __velarListIndexSet(value, index, next) {
+  value = __velarValidateOwnedList(value, "List index assignment");
+  index = __velarStrictListIndex(value, index);
+  const previous = __velarOwnedListElement(value, index, "List index assignment");
+  next = __velarReactiveRaw(next);
+  if (__velarCollectionListObjectIs(__velarReactiveRaw(previous), next)) return next;
+  value[index] = next;
+  __velarReactiveCollectionUnlink(value, previous);
+  __velarReactiveCollectionLink(value, next);
+  __velarReactiveCollectionTrigger(value, index, true, false);
+  __velarMarkOwnedList(value);
+  return next;
+}
+function __velarRecordIndexSet(value, index, next) {
   value = __velarReactiveRaw(value);
-  if (__velarCollectionListIsArray(value)) {
-    __velarValidateOwnedList(value, "List index assignment");
-    index = __velarStrictListIndex(value, index);
-    const previous = __velarOwnedListElement(value, index, "List index assignment");
-    next = __velarReactiveRaw(next);
-    if (__velarCollectionListObjectIs(__velarReactiveRaw(previous), next)) return next;
-    value[index] = next;
-    __velarReactiveCollectionUnlink(value, previous);
-    __velarReactiveCollectionLink(value, next);
-    __velarReactiveCollectionTrigger(value, index, true, false);
-    __velarMarkOwnedList(value);
-    return next;
-  }
-  if (!__velarIsRecord(value) || typeof index !== "string") throw new __velarCollectionNativeTypeError("Record index assignment requires a plain record and a string key");
+  if (typeof index !== "string") throw new __velarCollectionNativeTypeError("Record index assignment requires a plain record and a string key");
   const fields = __velarRecordFields(value, "Record index assignment");
   const descriptor = __velarCollectionRecordGetOwnPropertyDescriptor(value, index);
   if (descriptor === undefined && fields.length >= 1000000) throw new __velarCollectionRecordNativeRangeError("A Record cannot exceed 1000000 fields");
@@ -430,6 +488,10 @@ function __velarSetIndex(value, index, next) {
   __velarReactiveCollectionTrigger(value, index, true, descriptor === undefined);
   return next;
 }
+function __velarSetIndex(value, index, next) {
+  const raw = __velarReactiveRaw(value);
+  return __velarCollectionListIsArray(raw) ? __velarListIndexSet(raw, index, next) : __velarRecordIndexSet(raw, index, next);
+}
 
 function __velarListAppend(value, item) {
   value = __velarValidateOwnedList(value, "List.append");
@@ -675,17 +737,24 @@ function __velarRecordCopy(value) {
   return output;
 }
 
+function __velarListHas(value, item) { value = __velarValidateOwnedList(value, "List.has"); item = __velarReactiveRaw(item); __velarReactiveCollectionTrack(value); for (let index = 0; index < value.length; index += 1) if (__velarSameValueZero(__velarReactiveRaw(__velarOwnedListElement(value, index, "List.has")), item)) return true; return false; }
+function __velarRecordHas(value, item) { value = __velarReactiveRaw(value); item = __velarReactiveRaw(item); if (typeof item !== "string") throw new __velarCollectionNativeTypeError("Record.has requires a string key"); __velarRecordFields(value, "Record.has"); __velarReactiveCollectionTrack(value, item); return __velarCollectionRecordGetOwnPropertyDescriptor(value, item) !== undefined; }
+function __velarMapHas(value, item) { value = __velarReactiveRaw(value); item = __velarReactiveRaw(item); const size = __velarCheckedMapSize(value, "Map.has"); if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Map cannot exceed 1000000 entries"); __velarReactiveCollectionTrack(value, item); return __velarCollectionSetMapMapHas(value, item); }
+function __velarSetHas(value, item) { value = __velarReactiveRaw(value); item = __velarReactiveRaw(item); const size = __velarCheckedSetSize(value, "Set.has"); if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Set cannot exceed 1000000 items"); __velarReactiveCollectionTrack(value, item); return __velarCollectionSetMapSetHas(value, item); }
 function __velarCollectionHas(value, item) {
-  value = __velarReactiveRaw(value); item = __velarReactiveRaw(item);
-  if (__velarCollectionListIsArray(value)) { value = __velarValidateOwnedList(value, "List.has"); __velarReactiveCollectionTrack(value); for (let index = 0; index < value.length; index += 1) if (__velarSameValueZero(__velarReactiveRaw(__velarOwnedListElement(value, index, "List.has")), item)) return true; return false; }
-  if (__velarIsRecord(value)) { if (typeof item !== "string") throw new __velarCollectionNativeTypeError("Record.has requires a string key"); __velarRecordFields(value, "Record.has"); __velarReactiveCollectionTrack(value, item); return __velarCollectionRecordGetOwnPropertyDescriptor(value, item) !== undefined; }
-  const map = __velarIsMap(value); const set = !map && __velarIsSet(value);
-  if (!map && !set) throw new __velarCollectionNativeTypeError("VelarScript membership requires a List, Set, Map, or Record");
-  const size = map ? __velarCollectionSetMapMapSize(value) : __velarCollectionSetMapSetSize(value);
-  if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A collection cannot exceed 1000000 items");
-  __velarReactiveCollectionTrack(value, item);
-  return map ? __velarCollectionSetMapMapHas(value, item) : __velarCollectionSetMapSetHas(value, item);
+  const raw = __velarReactiveRaw(value);
+  if (__velarCollectionListIsArray(raw)) return __velarListHas(raw, item);
+  if (__velarIsRecord(raw)) return __velarRecordHas(raw, item);
+  if (__velarIsMap(raw)) return __velarMapHas(raw, item);
+  if (__velarIsSet(raw)) return __velarSetHas(raw, item);
+  throw new __velarCollectionNativeTypeError("VelarScript membership requires a List, Set, Map, or Record");
 }
+// Membership keeps source evaluation order (item before container) while the
+// method-shaped helpers keep receiver-first order for values.has(item).
+function __velarListContains(item, value) { return __velarListHas(value, item); }
+function __velarMapContains(item, value) { return __velarMapHas(value, item); }
+function __velarSetContains(item, value) { return __velarSetHas(value, item); }
+function __velarRecordContains(item, value) { return __velarRecordHas(value, item); }
 function __velarContains(item, value) {
   if (typeof value === "string") { if (typeof item !== "string") throw new __velarCollectionNativeTypeError("String membership requires a string"); return value.includes(item); }
   value = __velarReactiveRaw(value);
@@ -857,78 +926,153 @@ function __velarEqualsVisit(left, right, active, depth) {
   }
 }
 
-function __velarCollectionRemove(value, item) {
+function __velarRecordRemove(value, item) {
   value = __velarReactiveRaw(value); item = __velarReactiveRaw(item);
-  if (__velarIsRecord(value)) {
-    if (typeof item !== "string") throw new __velarCollectionNativeTypeError("Record.remove requires a string key");
-    __velarRecordFields(value, "Record.remove");
-    const descriptor = __velarCollectionRecordGetOwnPropertyDescriptor(value, item);
-    if (descriptor === undefined) return false;
-    if (!descriptor.configurable) throw new __velarCollectionNativeTypeError("Record.remove requires a configurable data field");
-    if (!__velarCollectionRecordDeleteProperty(value, item)) throw new __velarCollectionNativeTypeError("Record.remove could not delete the field");
-    __velarReactiveCollectionUnlink(value, descriptor.value);
-    __velarReactiveCollectionTrigger(value, item, true, true);
-    return true;
-  }
-  const map = __velarIsMap(value);
-  const previous = map ? __velarCollectionSetMapMapGet(value, item) : undefined;
-  const removed = map ? __velarCollectionSetMapMapDelete(value, item) : __velarCollectionSetMapSetDelete(value, item);
-  // A Set member is its own entry: unlinking it twice repeats an O(children)
-  // scan for nothing. Only a Map has a separate value to unlink.
-  if (removed) { __velarReactiveCollectionUnlink(value, item); if (map) __velarReactiveCollectionUnlink(value, previous); __velarReactiveCollectionTrigger(value, item, true, true); }
+  if (typeof item !== "string") throw new __velarCollectionNativeTypeError("Record.remove requires a string key");
+  __velarRecordFields(value, "Record.remove");
+  const descriptor = __velarCollectionRecordGetOwnPropertyDescriptor(value, item);
+  if (descriptor === undefined) return false;
+  if (!descriptor.configurable) throw new __velarCollectionNativeTypeError("Record.remove requires a configurable data field");
+  if (!__velarCollectionRecordDeleteProperty(value, item)) throw new __velarCollectionNativeTypeError("Record.remove could not delete the field");
+  __velarReactiveCollectionUnlink(value, descriptor.value);
+  __velarReactiveCollectionTrigger(value, item, true, true);
+  return true;
+}
+function __velarMapRemove(value, item) {
+  value = __velarReactiveRaw(value); item = __velarReactiveRaw(item);
+  const size = __velarCheckedMapSize(value, "Map.remove");
+  if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Map cannot exceed 1000000 entries");
+  const previous = __velarCollectionSetMapMapGet(value, item);
+  const removed = __velarCollectionSetMapMapDelete(value, item);
+  if (removed) { __velarReactiveCollectionUnlink(value, item); __velarReactiveCollectionUnlink(value, previous); __velarReactiveCollectionTrigger(value, item, true, true); }
   return removed;
 }
+function __velarSetRemove(value, item) {
+  value = __velarReactiveRaw(value); item = __velarReactiveRaw(item);
+  const size = __velarCheckedSetSize(value, "Set.remove");
+  if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Set cannot exceed 1000000 items");
+  const removed = __velarCollectionSetMapSetDelete(value, item);
+  if (removed) { __velarReactiveCollectionUnlink(value, item); __velarReactiveCollectionTrigger(value, item, true, true); }
+  return removed;
+}
+function __velarCollectionRemove(value, item) {
+  const raw = __velarReactiveRaw(value);
+  if (__velarIsRecord(raw)) return __velarRecordRemove(raw, item);
+  if (__velarIsMap(raw)) return __velarMapRemove(raw, item);
+  return __velarSetRemove(raw, item);
+}
 
-function __velarCollectionClear(value) {
+function __velarListClear(value) {
   value = __velarReactiveRaw(value);
-  if (__velarCollectionListIsArray(value)) {
-    const previous = __velarCopyList(value, "List.clear");
-    if (previous.length === 0) return null;
-    value.length = 0;
-    __velarMarkOwnedList(value);
-    for (let index = 0; index < previous.length; index += 1) __velarReactiveCollectionUnlink(value, previous[index]);
-    __velarReactiveCollectionTrigger(value, __velarReactiveIterateKey, true, true, 0);
-    return null;
-  }
-  if (__velarIsRecord(value)) {
-    const fields = __velarRecordFields(value, "Record.clear");
-    if (fields.length === 0) return null;
-    const previous = new __velarCollectionNativeArray(fields.length);
-    for (let index = 0; index < fields.length; index += 1) { const descriptor = __velarCollectionRecordGetOwnPropertyDescriptor(value, fields[index]); if (!descriptor.configurable) throw new __velarCollectionNativeTypeError("Record.clear requires configurable data fields"); previous[index] = descriptor.value; }
-    for (let index = 0; index < fields.length; index += 1) if (!__velarCollectionRecordDeleteProperty(value, fields[index])) throw new __velarCollectionNativeTypeError("Record.clear could not delete a field");
-    for (let index = 0; index < previous.length; index += 1) __velarReactiveCollectionUnlink(value, previous[index]);
-    __velarReactiveCollectionTrigger(value, __velarReactiveIterateKey, true, true, null, true);
-    return null;
-  }
-  const map = __velarIsMap(value);
-  const previous = [];
-  if (map) { const iterator = __velarCollectionSetMapMapEntries(value); while (true) { const step = __velarCollectionSetMapMapNext(iterator); if (step.done) break; const entry = step.value; previous[previous.length] = entry[0]; previous[previous.length] = entry[1]; } }
-  else { const iterator = __velarCollectionSetMapSetValues(value); while (true) { const step = __velarCollectionSetMapSetNext(iterator); if (step.done) break; previous[previous.length] = step.value; } }
+  const previous = __velarCopyList(value, "List.clear");
   if (previous.length === 0) return null;
-  if (map) __velarCollectionSetMapMapClear(value); else __velarCollectionSetMapSetClear(value);
+  value.length = 0;
+  __velarMarkOwnedList(value);
   for (let index = 0; index < previous.length; index += 1) __velarReactiveCollectionUnlink(value, previous[index]);
+  __velarReactiveCollectionTrigger(value, __velarReactiveIterateKey, true, true, 0);
+  return null;
+}
+function __velarRecordClear(value) {
+  value = __velarReactiveRaw(value);
+  const fields = __velarRecordFields(value, "Record.clear");
+  if (fields.length === 0) return null;
+  const previous = new __velarCollectionNativeArray(fields.length);
+  for (let index = 0; index < fields.length; index += 1) { const descriptor = __velarCollectionRecordGetOwnPropertyDescriptor(value, fields[index]); if (!descriptor.configurable) throw new __velarCollectionNativeTypeError("Record.clear requires configurable data fields"); previous[index] = descriptor.value; }
+  for (let index = 0; index < fields.length; index += 1) if (!__velarCollectionRecordDeleteProperty(value, fields[index])) throw new __velarCollectionNativeTypeError("Record.clear could not delete a field");
+  for (let index = 0; index < previous.length; index += 1) __velarReactiveCollectionUnlink(value, previous[index]);
+  __velarReactiveCollectionTrigger(value, __velarReactiveIterateKey, true, true, null, true);
+  return null;
+}
+function __velarMapClear(value) {
+  value = __velarReactiveRaw(value);
+  const size = __velarCheckedMapSize(value, "Map.clear");
+  if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Map cannot exceed 1000000 entries");
+  if (size === 0) return null;
+  const previous = new __velarCollectionNativeArray(size * 2);
+  const iterator = __velarCollectionSetMapMapEntries(value);
+  let index = 0;
+  while (true) { const step = __velarCollectionSetMapMapNext(iterator); if (step.done) break; previous[index++] = step.value[0]; previous[index++] = step.value[1]; }
+  __velarCollectionSetMapMapClear(value);
+  for (let previousIndex = 0; previousIndex < previous.length; previousIndex += 1) __velarReactiveCollectionUnlink(value, previous[previousIndex]);
+  __velarReactiveCollectionTrigger(value, __velarReactiveIterateKey, true, true, null, true);
+  return null;
+}
+function __velarSetClear(value) {
+  value = __velarReactiveRaw(value);
+  const size = __velarCheckedSetSize(value, "Set.clear");
+  if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Set cannot exceed 1000000 items");
+  if (size === 0) return null;
+  const previous = new __velarCollectionNativeArray(size);
+  const iterator = __velarCollectionSetMapSetValues(value);
+  let index = 0;
+  while (true) { const step = __velarCollectionSetMapSetNext(iterator); if (step.done) break; previous[index++] = step.value; }
+  __velarCollectionSetMapSetClear(value);
+  for (let previousIndex = 0; previousIndex < previous.length; previousIndex += 1) __velarReactiveCollectionUnlink(value, previous[previousIndex]);
   __velarReactiveCollectionTrigger(value, __velarReactiveIterateKey, true, true, null, true);
   return null;
 }
+function __velarCollectionClear(value) {
+  const raw = __velarReactiveRaw(value);
+  if (__velarCollectionListIsArray(raw)) return __velarListClear(raw);
+  if (__velarIsRecord(raw)) return __velarRecordClear(raw);
+  if (__velarIsMap(raw)) return __velarMapClear(raw);
+  return __velarSetClear(raw);
+}
 
-function __velarCollectionKeys(value) {
+function __velarRecordKeys(value) {
+  value = __velarReactiveRaw(value); __velarReactiveCollectionTrack(value, __velarReactiveStructureKey);
+  const fields = __velarRecordFields(value, "Record.keys");
+  const output = new __velarCollectionNativeArray(fields.length);
+  for (let index = 0; index < fields.length; index += 1) output[index] = __velarReactiveCollectionRead(value, __velarReactiveStructureKey, fields[index]);
+  return __velarMarkOwnedList(output);
+}
+function __velarMapKeys(value) {
   value = __velarReactiveRaw(value); __velarReactiveCollectionTrack(value, __velarReactiveStructureKey);
-  if (__velarIsRecord(value)) { const fields = __velarRecordFields(value, "Record.keys"); const output = new __velarCollectionNativeArray(fields.length); for (let index = 0; index < fields.length; index += 1) output[index] = __velarReactiveCollectionRead(value, __velarReactiveStructureKey, fields[index]); return __velarMarkOwnedList(output); }
-  const size = __velarCollectionSetMapMapSize(value); if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Map cannot exceed 1000000 entries");
-  const output = new __velarCollectionNativeArray(size); const iterator = __velarCollectionSetMapMapKeys(value); let index = 0; while (true) { const step = __velarCollectionSetMapMapNext(iterator); if (step.done) return __velarMarkOwnedList(output); output[index++] = __velarReactiveCollectionRead(value, __velarReactiveStructureKey, step.value); }
+  const size = __velarCheckedMapSize(value, "Map.keys");
+  if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Map cannot exceed 1000000 entries");
+  const output = new __velarCollectionNativeArray(size); const iterator = __velarCollectionSetMapMapKeys(value); let index = 0;
+  while (true) { const step = __velarCollectionSetMapMapNext(iterator); if (step.done) return __velarMarkOwnedList(output); output[index++] = __velarReactiveCollectionRead(value, __velarReactiveStructureKey, step.value); }
+}
+function __velarCollectionKeys(value) { value = __velarReactiveRaw(value); return __velarIsRecord(value) ? __velarRecordKeys(value) : __velarMapKeys(value); }
+
+function __velarRecordValues(value) {
+  value = __velarReactiveRaw(value); __velarReactiveCollectionTrack(value);
+  const fields = __velarRecordFields(value, "Record.values"); const output = new __velarCollectionNativeArray(fields.length);
+  for (let index = 0; index < fields.length; index += 1) { const field = fields[index]; output[index] = __velarReactiveCollectionRead(value, field, __velarCollectionRecordGetOwnPropertyDescriptor(value, field).value); }
+  return __velarMarkOwnedList(output);
+}
+function __velarMapValues(value) {
+  value = __velarReactiveRaw(value); __velarReactiveCollectionTrack(value);
+  const size = __velarCheckedMapSize(value, "Map.values"); if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Map cannot exceed 1000000 entries");
+  const output = new __velarCollectionNativeArray(size); const iterator = __velarCollectionSetMapMapValues(value); let index = 0;
+  while (true) { const step = __velarCollectionSetMapMapNext(iterator); if (step.done) return __velarMarkOwnedList(output); output[index++] = __velarReactiveCollectionRead(value, __velarReactiveIterateKey, step.value); }
+}
+function __velarSetValues(value) {
+  value = __velarReactiveRaw(value); __velarReactiveCollectionTrack(value);
+  const size = __velarCheckedSetSize(value, "Set.values"); if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Set cannot exceed 1000000 items");
+  const output = new __velarCollectionNativeArray(size); const iterator = __velarCollectionSetMapSetValues(value); let index = 0;
+  while (true) { const step = __velarCollectionSetMapSetNext(iterator); if (step.done) return __velarMarkOwnedList(output); output[index++] = __velarReactiveCollectionRead(value, __velarReactiveIterateKey, step.value); }
 }
 function __velarCollectionValues(value) {
+  value = __velarReactiveRaw(value);
+  if (__velarIsRecord(value)) return __velarRecordValues(value);
+  if (__velarIsMap(value)) return __velarMapValues(value);
+  return __velarSetValues(value);
+}
+
+function __velarRecordEntries(value) {
   value = __velarReactiveRaw(value); __velarReactiveCollectionTrack(value);
-  if (__velarIsRecord(value)) { const fields = __velarRecordFields(value, "Record.values"); const output = new __velarCollectionNativeArray(fields.length); for (let index = 0; index < fields.length; index += 1) { const field = fields[index]; output[index] = __velarReactiveCollectionRead(value, field, __velarCollectionRecordGetOwnPropertyDescriptor(value, field).value); } return __velarMarkOwnedList(output); }
-  const map = __velarIsMap(value); const size = map ? __velarCollectionSetMapMapSize(value) : __velarCollectionSetMapSetSize(value); if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A collection cannot exceed 1000000 items");
-  const output = new __velarCollectionNativeArray(size); const iterator = map ? __velarCollectionSetMapMapValues(value) : __velarCollectionSetMapSetValues(value); let index = 0; while (true) { const step = map ? __velarCollectionSetMapMapNext(iterator) : __velarCollectionSetMapSetNext(iterator); if (step.done) return __velarMarkOwnedList(output); output[index++] = __velarReactiveCollectionRead(value, __velarReactiveIterateKey, step.value); }
+  const fields = __velarRecordFields(value, "Record.entries"); const output = new __velarCollectionNativeArray(fields.length);
+  for (let index = 0; index < fields.length; index += 1) { const field = fields[index]; output[index] = __velarCollectionRecordFreeze({ key: __velarReactiveCollectionRead(value, __velarReactiveIterateKey, field), value: __velarReactiveCollectionRead(value, field, __velarCollectionRecordGetOwnPropertyDescriptor(value, field).value) }); }
+  return __velarMarkOwnedList(output);
 }
-function __velarCollectionEntries(value) {
+function __velarMapEntries(value) {
   value = __velarReactiveRaw(value); __velarReactiveCollectionTrack(value);
-  if (__velarIsRecord(value)) { const fields = __velarRecordFields(value, "Record.entries"); const output = new __velarCollectionNativeArray(fields.length); for (let index = 0; index < fields.length; index += 1) { const field = fields[index]; output[index] = __velarCollectionRecordFreeze({ key: __velarReactiveCollectionRead(value, __velarReactiveIterateKey, field), value: __velarReactiveCollectionRead(value, field, __velarCollectionRecordGetOwnPropertyDescriptor(value, field).value) }); } return __velarMarkOwnedList(output); }
-  const size = __velarCollectionSetMapMapSize(value); if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Map cannot exceed 1000000 entries");
-  const output = new __velarCollectionNativeArray(size); const iterator = __velarCollectionSetMapMapEntries(value); let index = 0; while (true) { const step = __velarCollectionSetMapMapNext(iterator); if (step.done) return __velarMarkOwnedList(output); const entry = step.value; output[index++] = __velarCollectionSetMapFreeze({ key: __velarReactiveCollectionRead(value, __velarReactiveIterateKey, entry[0]), value: __velarReactiveCollectionRead(value, entry[0], entry[1]) }); }
+  const size = __velarCheckedMapSize(value, "Map.entries"); if (size > __velarMaxCollectionItems) throw new __velarCollectionSetMapNativeRangeError("A Map cannot exceed 1000000 entries");
+  const output = new __velarCollectionNativeArray(size); const iterator = __velarCollectionSetMapMapEntries(value); let index = 0;
+  while (true) { const step = __velarCollectionSetMapMapNext(iterator); if (step.done) return __velarMarkOwnedList(output); const entry = step.value; output[index++] = __velarCollectionSetMapFreeze({ key: __velarReactiveCollectionRead(value, __velarReactiveIterateKey, entry[0]), value: __velarReactiveCollectionRead(value, entry[0], entry[1]) }); }
 }
+function __velarCollectionEntries(value) { value = __velarReactiveRaw(value); return __velarIsRecord(value) ? __velarRecordEntries(value) : __velarMapEntries(value); }
 function __velarOptionalCollection(value, operation) { return value == null ? null : operation(value); }`;
 export const VELAR_COLLECTION_LOWERING_MODULE_SOURCE = String.raw `
 import {

package/dist/collection-lowering-runtime.js.map

@@ -1 +1 @@
-{"version":3,"file":"collection-lowering-runtime.js","sourceRoot":"","sources":["../src/collection-lowering-runtime.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"collection-lowering-runtime.js","sourceRoot":"","sources":["../src/collection-lowering-runtime.ts"],"names":[],"mappings":"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"}

package/dist/core-vocabulary.d.ts

@@ -80,6 +80,10 @@ export declare const CORE_CONTEXTUAL_KEYWORDS: readonly [{
     readonly word: "get";
     readonly shape: "a class getter: 'get empty() -> bool:'";
     readonly statementSubjectFollows: false;
+}, {
+    readonly word: "json";
+    readonly shape: "a checked JSON resource import: 'import json data from \"package/data\"'";
+    readonly statementSubjectFollows: false;
 }, {
     readonly word: "match";
     readonly shape: "a match statement: 'match value:'";

package/dist/core-vocabulary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core-vocabulary.d.ts","sourceRoot":"","sources":["../src/core-vocabulary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,iFAAiF;AACjF,eAAO,MAAM,yBAAyB,YAAI,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAU,CAAC;AAEtF,4EAA4E;AAC5E,eAAO,MAAM,kBAAkB,YAAI,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAU,CAAC;AAEzF,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAC;AAChF,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC;AAClE,MAAM,MAAM,kBAAkB,GAAG,sBAAsB,GAAG,eAAe,CAAC;AAE1E,kFAAkF;AAClF,eAAO,MAAM,qBAAqB,EAAE,SAAS,kBAAkB,EAG9D,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,sBAAsB,CAErF;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,qBAAqB;IACpC,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;;;;OAOG;IACH,QAAQ,CAAC,uBAAuB,EAAE,OAAO,CAAC;CAC3C;AAED,eAAO,MAAM,wBAAwB;mBAC3B,IAAI;oBAAS,mFAAmF;;;mBAChG,MAAM;oBAAS,qCAAqC;;;mBACpD,aAAa;oBAAS,6DAA6D;;;mBACnF,MAAM;oBAAS,0EAA0E;;;mBACzF,KAAK;oBAAS,wCAAwC;;;mBACtD,OAAO;oBAAS,mCAAmC;;;mBACnD,UAAU;oBAAS,iEAAiE;;;mBACpF,MAAM;oBAAS,wCAAwC;;;mBACvD,MAAM;oBAAS,iEAAiE;;;mBAChF,OAAO;oBAAS,sDAAsD;;EAC3B,CAAC;AAEtD,MAAM,MAAM,yBAAyB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1F;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE;IAAE,QAAQ,EAAE,IAAI,IAAI,yBAAyB,GAAG,IAAI;CAElB,CAAC;AAE5D,8EAA8E;AAC9E,eAAO,MAAM,6BAA6B,EAAE,SAAS,yBAAyB,EACzB,CAAC;AAEtD;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,EAAE,SAAS,yBAAyB,EAEhD,CAAC;AAE9B;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,YAAI,IAAI,EAAE,GAAG,CAAU,CAAC;AAC1D,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvE;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC,YAAI,KAAK,EAAE,MAAM,CAAU,CAAC;AACzE,MAAM,MAAM,4BAA4B,GAAG,CAAC,OAAO,gCAAgC,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7F,mFAAmF;AACnF,wBAAgB,mCAAmC,IAAI,MAAM,CAI5D"}
+{"version":3,"file":"core-vocabulary.d.ts","sourceRoot":"","sources":["../src/core-vocabulary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,iFAAiF;AACjF,eAAO,MAAM,yBAAyB,YAAI,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAU,CAAC;AAEtF,4EAA4E;AAC5E,eAAO,MAAM,kBAAkB,YAAI,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAU,CAAC;AAEzF,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAC;AAChF,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC;AAClE,MAAM,MAAM,kBAAkB,GAAG,sBAAsB,GAAG,eAAe,CAAC;AAE1E,kFAAkF;AAClF,eAAO,MAAM,qBAAqB,EAAE,SAAS,kBAAkB,EAG9D,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,sBAAsB,CAErF;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,qBAAqB;IACpC,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;;;;OAOG;IACH,QAAQ,CAAC,uBAAuB,EAAE,OAAO,CAAC;CAC3C;AAED,eAAO,MAAM,wBAAwB;mBAC3B,IAAI;oBAAS,mFAAmF;;;mBAChG,MAAM;oBAAS,qCAAqC;;;mBACpD,aAAa;oBAAS,6DAA6D;;;mBACnF,MAAM;oBAAS,0EAA0E;;;mBACzF,KAAK;oBAAS,wCAAwC;;;mBACtD,MAAM;oBAAS,0EAA0E;;;mBACzF,OAAO;oBAAS,mCAAmC;;;mBACnD,UAAU;oBAAS,iEAAiE;;;mBACpF,MAAM;oBAAS,wCAAwC;;;mBACvD,MAAM;oBAAS,iEAAiE;;;mBAChF,OAAO;oBAAS,sDAAsD;;EAC3B,CAAC;AAEtD,MAAM,MAAM,yBAAyB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1F;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE;IAAE,QAAQ,EAAE,IAAI,IAAI,yBAAyB,GAAG,IAAI;CAElB,CAAC;AAE5D,8EAA8E;AAC9E,eAAO,MAAM,6BAA6B,EAAE,SAAS,yBAAyB,EACzB,CAAC;AAEtD;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,EAAE,SAAS,yBAAyB,EAEhD,CAAC;AAE9B;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,YAAI,IAAI,EAAE,GAAG,CAAU,CAAC;AAC1D,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvE;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC,YAAI,KAAK,EAAE,MAAM,CAAU,CAAC;AACzE,MAAM,MAAM,4BAA4B,GAAG,CAAC,OAAO,gCAAgC,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7F,mFAAmF;AACnF,wBAAgB,mCAAmC,IAAI,MAAM,CAI5D"}

package/dist/core-vocabulary.js

@@ -41,6 +41,7 @@ export const CORE_CONTEXTUAL_KEYWORDS = [
     { word: "constructor", shape: "a class's construction member: 'constructor(name: string):'", statementSubjectFollows: false },
     { word: "from", shape: "the module an import or a re-export reads: 'import {a} from \"./m.vel\"'", statementSubjectFollows: false },
     { word: "get", shape: "a class getter: 'get empty() -> bool:'", statementSubjectFollows: false },
+    { word: "json", shape: "a checked JSON resource import: 'import json data from \"package/data\"'", statementSubjectFollows: false },
     { word: "match", shape: "a match statement: 'match value:'", statementSubjectFollows: true },
     { word: "readonly", shape: "a read-only record field or type: 'readonly tags: List<string>'", statementSubjectFollows: false },
     { word: "test", shape: "a test declaration: 'test \"a name\":'", statementSubjectFollows: false },

package/dist/core-vocabulary.js.map

@@ -1 +1 @@
-{"version":3,"file":"core-vocabulary.js","sourceRoot":"","sources":["../src/core-vocabulary.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"core-vocabulary.js","sourceRoot":"","sources":["../src/core-vocabulary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,iFAAiF;AACjF,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAU,CAAC;AAEtF,4EAA4E;AAC5E,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAU,CAAC;AAMzF,kFAAkF;AAClF,MAAM,CAAC,MAAM,qBAAqB,GAAkC;IAClE,GAAG,yBAAyB;IAC5B,GAAG,kBAAkB;CACtB,CAAC;AAEF,MAAM,UAAU,wBAAwB,CAAC,IAAY;IACnD,OAAQ,yBAA+C,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AACzE,CAAC;AA8BD,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,mFAAmF,EAAE,uBAAuB,EAAE,KAAK,EAAE;IAC1I,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,qCAAqC,EAAE,uBAAuB,EAAE,IAAI,EAAE;IAC7F,EAAE,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,6DAA6D,EAAE,uBAAuB,EAAE,KAAK,EAAE;IAC7H,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,0EAA0E,EAAE,uBAAuB,EAAE,KAAK,EAAE;IACnI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,wCAAwC,EAAE,uBAAuB,EAAE,KAAK,EAAE;IAChG,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,0EAA0E,EAAE,uBAAuB,EAAE,KAAK,EAAE;IACnI,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,mCAAmC,EAAE,uBAAuB,EAAE,IAAI,EAAE;IAC5F,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,iEAAiE,EAAE,uBAAuB,EAAE,KAAK,EAAE;IAC9H,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,wCAAwC,EAAE,uBAAuB,EAAE,KAAK,EAAE;IACjG,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,iEAAiE,EAAE,uBAAuB,EAAE,KAAK,EAAE;IAC1H,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,sDAAsD,EAAE,uBAAuB,EAAE,KAAK,EAAE;CAC7D,CAAC;AAItD;;;;GAIG;AACH,MAAM,CAAC,MAAM,UAAU,GAA2D,MAAM,CAAC,MAAM,CAC7F,MAAM,CAAC,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAC5B,CAAC;AAE5D,8EAA8E;AAC9E,MAAM,CAAC,MAAM,6BAA6B,GACxC,wBAAwB,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AAEtD;;;;GAIG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAyC,wBAAwB;KACvG,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,uBAAuB,CAAC;KAChD,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AAE9B;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,GAAG,CAAU,CAAC;AAG1D;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAU,CAAC;AAGzE,mFAAmF;AACnF,MAAM,UAAU,mCAAmC;IACjD,MAAM,SAAS,GAAiD,EAAE,GAAG,EAAE,iBAAiB,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC;IACnH,MAAM,KAAK,GAAG,gCAAgC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;IAC9E,OAAO,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AACrG,CAAC"}