@rocicorp/zero 0.26.1 → 0.26.2-canary.4

package/out/zql/src/builder/filter.js.map

@@ -1 +1 @@
-{"version":3,"file":"filter.js","sources":["../../../../../zql/src/builder/filter.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport type {\n  Condition,\n  SimpleCondition,\n  SimpleOperator,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport {simplifyCondition} from '../query/expression.ts';\nimport {getLikePredicate} from './like.ts';\n\nexport type NonNullValue = Exclude<Value, null | undefined>;\nexport type SimplePredicate = (rhs: Value) => boolean;\nexport type SimplePredicateNoNull = (rhs: NonNullValue) => boolean;\n\nexport type NoSubqueryCondition =\n  | SimpleCondition\n  | {\n      type: 'and';\n      conditions: readonly NoSubqueryCondition[];\n    }\n  | {\n      type: 'or';\n      conditions: readonly NoSubqueryCondition[];\n    };\n\nexport function createPredicate(\n  condition: NoSubqueryCondition,\n): (row: Row) => boolean {\n  if (condition.type !== 'simple') {\n    const predicates = condition.conditions.map(c => createPredicate(c));\n    return condition.type === 'and'\n      ? (row: Row) => {\n          // and\n          for (const predicate of predicates) {\n            if (!predicate(row)) {\n              return false;\n            }\n          }\n          return true;\n        }\n      : (row: Row) => {\n          // or\n          for (const predicate of predicates) {\n            if (predicate(row)) {\n              return true;\n            }\n          }\n          return false;\n        };\n  }\n  const {left} = condition;\n  const {right} = condition;\n  assert(\n    right.type !== 'static',\n    'static values should be resolved before creating predicates',\n  );\n  assert(\n    left.type !== 'static',\n    'static values should be resolved before creating predicates',\n  );\n\n  switch (condition.op) {\n    case 'IS':\n    case 'IS NOT': {\n      const impl = createIsPredicate(right.value, condition.op);\n      if (left.type === 'literal') {\n        const result = impl(left.value);\n        return () => result;\n      }\n      return (row: Row) => impl(row[left.name]);\n    }\n  }\n\n  if (right.value === null || right.value === undefined) {\n    return (_row: Row) => false;\n  }\n\n  const impl = createPredicateImpl(right.value, condition.op);\n  if (left.type === 'literal') {\n    if (left.value === null || left.value === undefined) {\n      return (_row: Row) => false;\n    }\n    const result = impl(left.value);\n    return () => result;\n  }\n\n  return (row: Row) => {\n    const lhs = row[left.name];\n    if (lhs === null || lhs === undefined) {\n      return false;\n    }\n    return impl(lhs);\n  };\n}\n\nfunction createIsPredicate(\n  rhs: Value | readonly Value[],\n  operator: 'IS' | 'IS NOT',\n): SimplePredicate {\n  switch (operator) {\n    case 'IS':\n      return lhs => lhs === rhs;\n    case 'IS NOT':\n      return lhs => lhs !== rhs;\n  }\n}\n\nfunction createPredicateImpl(\n  rhs: NonNullValue | readonly NonNullValue[],\n  operator: Exclude<SimpleOperator, 'IS' | 'IS NOT'>,\n): SimplePredicateNoNull {\n  switch (operator) {\n    case '=':\n      return lhs => lhs === rhs;\n    case '!=':\n      return lhs => lhs !== rhs;\n    case '<':\n      return lhs => lhs < rhs;\n    case '<=':\n      return lhs => lhs <= rhs;\n    case '>':\n      return lhs => lhs > rhs;\n    case '>=':\n      return lhs => lhs >= rhs;\n    case 'LIKE':\n      return getLikePredicate(rhs, '');\n    case 'NOT LIKE':\n      return not(getLikePredicate(rhs, ''));\n    case 'ILIKE':\n      return getLikePredicate(rhs, 'i');\n    case 'NOT ILIKE':\n      return not(getLikePredicate(rhs, 'i'));\n    case 'IN': {\n      assert(Array.isArray(rhs), 'Expected rhs to be an array for IN operator');\n      const set = new Set(rhs);\n      return lhs => set.has(lhs);\n    }\n    case 'NOT IN': {\n      assert(\n        Array.isArray(rhs),\n        'Expected rhs to be an array for NOT IN operator',\n      );\n      const set = new Set(rhs);\n      return lhs => !set.has(lhs);\n    }\n    default:\n      operator satisfies never;\n      throw new Error(`Unexpected operator: ${operator}`);\n  }\n}\n\nfunction not<T>(f: (lhs: T) => boolean) {\n  return (lhs: T) => !f(lhs);\n}\n\n/**\n * If the condition contains any CorrelatedSubqueryConditions, returns a\n * transformed condition which contains no CorrelatedSubqueryCondition(s) but\n * which will filter a subset of the rows that would be filtered by the original\n * condition, or undefined if no such transformation exists.\n *\n * If the condition does not contain any CorrelatedSubqueryConditions\n * returns the condition unmodified and `conditionsRemoved: false`.\n */\nexport function transformFilters(filters: Condition | undefined): {\n  filters: NoSubqueryCondition | undefined;\n  conditionsRemoved: boolean;\n} {\n  if (!filters) {\n    return {filters: undefined, conditionsRemoved: false};\n  }\n  switch (filters.type) {\n    case 'simple':\n      return {filters, conditionsRemoved: false};\n    case 'correlatedSubquery':\n      return {filters: undefined, conditionsRemoved: true};\n    case 'and':\n    case 'or': {\n      const transformedConditions: NoSubqueryCondition[] = [];\n      let conditionsRemoved = false;\n      for (const cond of filters.conditions) {\n        const transformed = transformFilters(cond);\n        // If any branch of the OR ends up empty, the entire OR needs\n        // to be removed.\n        if (transformed.filters === undefined && filters.type === 'or') {\n          return {filters: undefined, conditionsRemoved: true};\n        }\n        conditionsRemoved = conditionsRemoved || transformed.conditionsRemoved;\n        if (transformed.filters) {\n          transformedConditions.push(transformed.filters);\n        }\n      }\n      return {\n        filters: simplifyCondition({\n          type: filters.type,\n          conditions: transformedConditions,\n        }) as NoSubqueryCondition,\n        conditionsRemoved,\n      };\n    }\n    default:\n      unreachable(filters);\n  }\n}\n"],"names":["impl"],"mappings":"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"}
+{"version":3,"file":"filter.js","names":[],"sources":["../../../../../zql/src/builder/filter.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport type {\n  Condition,\n  SimpleCondition,\n  SimpleOperator,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport {simplifyCondition} from '../query/expression.ts';\nimport {getLikePredicate} from './like.ts';\n\nexport type NonNullValue = Exclude<Value, null | undefined>;\nexport type SimplePredicate = (rhs: Value) => boolean;\nexport type SimplePredicateNoNull = (rhs: NonNullValue) => boolean;\n\nexport type NoSubqueryCondition =\n  | SimpleCondition\n  | {\n      type: 'and';\n      conditions: readonly NoSubqueryCondition[];\n    }\n  | {\n      type: 'or';\n      conditions: readonly NoSubqueryCondition[];\n    };\n\nexport function createPredicate(\n  condition: NoSubqueryCondition,\n): (row: Row) => boolean {\n  if (condition.type !== 'simple') {\n    const predicates = condition.conditions.map(c => createPredicate(c));\n    return condition.type === 'and'\n      ? (row: Row) => {\n          // and\n          for (const predicate of predicates) {\n            if (!predicate(row)) {\n              return false;\n            }\n          }\n          return true;\n        }\n      : (row: Row) => {\n          // or\n          for (const predicate of predicates) {\n            if (predicate(row)) {\n              return true;\n            }\n          }\n          return false;\n        };\n  }\n  const {left} = condition;\n  const {right} = condition;\n  assert(\n    right.type !== 'static',\n    'static values should be resolved before creating predicates',\n  );\n  assert(\n    left.type !== 'static',\n    'static values should be resolved before creating predicates',\n  );\n\n  switch (condition.op) {\n    case 'IS':\n    case 'IS NOT': {\n      const impl = createIsPredicate(right.value, condition.op);\n      if (left.type === 'literal') {\n        const result = impl(left.value);\n        return () => result;\n      }\n      return (row: Row) => impl(row[left.name]);\n    }\n  }\n\n  if (right.value === null || right.value === undefined) {\n    return (_row: Row) => false;\n  }\n\n  const impl = createPredicateImpl(right.value, condition.op);\n  if (left.type === 'literal') {\n    if (left.value === null || left.value === undefined) {\n      return (_row: Row) => false;\n    }\n    const result = impl(left.value);\n    return () => result;\n  }\n\n  return (row: Row) => {\n    const lhs = row[left.name];\n    if (lhs === null || lhs === undefined) {\n      return false;\n    }\n    return impl(lhs);\n  };\n}\n\nfunction createIsPredicate(\n  rhs: Value | readonly Value[],\n  operator: 'IS' | 'IS NOT',\n): SimplePredicate {\n  switch (operator) {\n    case 'IS':\n      return lhs => lhs === rhs;\n    case 'IS NOT':\n      return lhs => lhs !== rhs;\n  }\n}\n\nfunction createPredicateImpl(\n  rhs: NonNullValue | readonly NonNullValue[],\n  operator: Exclude<SimpleOperator, 'IS' | 'IS NOT'>,\n): SimplePredicateNoNull {\n  switch (operator) {\n    case '=':\n      return lhs => lhs === rhs;\n    case '!=':\n      return lhs => lhs !== rhs;\n    case '<':\n      return lhs => lhs < rhs;\n    case '<=':\n      return lhs => lhs <= rhs;\n    case '>':\n      return lhs => lhs > rhs;\n    case '>=':\n      return lhs => lhs >= rhs;\n    case 'LIKE':\n      return getLikePredicate(rhs, '');\n    case 'NOT LIKE':\n      return not(getLikePredicate(rhs, ''));\n    case 'ILIKE':\n      return getLikePredicate(rhs, 'i');\n    case 'NOT ILIKE':\n      return not(getLikePredicate(rhs, 'i'));\n    case 'IN': {\n      assert(Array.isArray(rhs), 'Expected rhs to be an array for IN operator');\n      const set = new Set(rhs);\n      return lhs => set.has(lhs);\n    }\n    case 'NOT IN': {\n      assert(\n        Array.isArray(rhs),\n        'Expected rhs to be an array for NOT IN operator',\n      );\n      const set = new Set(rhs);\n      return lhs => !set.has(lhs);\n    }\n    default:\n      operator satisfies never;\n      throw new Error(`Unexpected operator: ${operator}`);\n  }\n}\n\nfunction not<T>(f: (lhs: T) => boolean) {\n  return (lhs: T) => !f(lhs);\n}\n\n/**\n * If the condition contains any CorrelatedSubqueryConditions, returns a\n * transformed condition which contains no CorrelatedSubqueryCondition(s) but\n * which will filter a subset of the rows that would be filtered by the original\n * condition, or undefined if no such transformation exists.\n *\n * If the condition does not contain any CorrelatedSubqueryConditions\n * returns the condition unmodified and `conditionsRemoved: false`.\n */\nexport function transformFilters(filters: Condition | undefined): {\n  filters: NoSubqueryCondition | undefined;\n  conditionsRemoved: boolean;\n} {\n  if (!filters) {\n    return {filters: undefined, conditionsRemoved: false};\n  }\n  switch (filters.type) {\n    case 'simple':\n      return {filters, conditionsRemoved: false};\n    case 'correlatedSubquery':\n      return {filters: undefined, conditionsRemoved: true};\n    case 'and':\n    case 'or': {\n      const transformedConditions: NoSubqueryCondition[] = [];\n      let conditionsRemoved = false;\n      for (const cond of filters.conditions) {\n        const transformed = transformFilters(cond);\n        // If any branch of the OR ends up empty, the entire OR needs\n        // to be removed.\n        if (transformed.filters === undefined && filters.type === 'or') {\n          return {filters: undefined, conditionsRemoved: true};\n        }\n        conditionsRemoved = conditionsRemoved || transformed.conditionsRemoved;\n        if (transformed.filters) {\n          transformedConditions.push(transformed.filters);\n        }\n      }\n      return {\n        filters: simplifyCondition({\n          type: filters.type,\n          conditions: transformedConditions,\n        }) as NoSubqueryCondition,\n        conditionsRemoved,\n      };\n    }\n    default:\n      unreachable(filters);\n  }\n}\n"],"mappings":";;;;AAyBA,SAAgB,gBACd,WACuB;AACvB,KAAI,UAAU,SAAS,UAAU;EAC/B,MAAM,aAAa,UAAU,WAAW,KAAI,MAAK,gBAAgB,EAAE,CAAC;AACpE,SAAO,UAAU,SAAS,SACrB,QAAa;AAEZ,QAAK,MAAM,aAAa,WACtB,KAAI,CAAC,UAAU,IAAI,CACjB,QAAO;AAGX,UAAO;OAER,QAAa;AAEZ,QAAK,MAAM,aAAa,WACtB,KAAI,UAAU,IAAI,CAChB,QAAO;AAGX,UAAO;;;CAGf,MAAM,EAAC,SAAQ;CACf,MAAM,EAAC,UAAS;AAChB,QACE,MAAM,SAAS,UACf,8DACD;AACD,QACE,KAAK,SAAS,UACd,8DACD;AAED,SAAQ,UAAU,IAAlB;EACE,KAAK;EACL,KAAK,UAAU;GACb,MAAM,OAAO,kBAAkB,MAAM,OAAO,UAAU,GAAG;AACzD,OAAI,KAAK,SAAS,WAAW;IAC3B,MAAM,SAAS,KAAK,KAAK,MAAM;AAC/B,iBAAa;;AAEf,WAAQ,QAAa,KAAK,IAAI,KAAK,MAAM;;;AAI7C,KAAI,MAAM,UAAU,QAAQ,MAAM,UAAU,KAAA,EAC1C,SAAQ,SAAc;CAGxB,MAAM,OAAO,oBAAoB,MAAM,OAAO,UAAU,GAAG;AAC3D,KAAI,KAAK,SAAS,WAAW;AAC3B,MAAI,KAAK,UAAU,QAAQ,KAAK,UAAU,KAAA,EACxC,SAAQ,SAAc;EAExB,MAAM,SAAS,KAAK,KAAK,MAAM;AAC/B,eAAa;;AAGf,SAAQ,QAAa;EACnB,MAAM,MAAM,IAAI,KAAK;AACrB,MAAI,QAAQ,QAAQ,QAAQ,KAAA,EAC1B,QAAO;AAET,SAAO,KAAK,IAAI;;;AAIpB,SAAS,kBACP,KACA,UACiB;AACjB,SAAQ,UAAR;EACE,KAAK,KACH,SAAO,QAAO,QAAQ;EACxB,KAAK,SACH,SAAO,QAAO,QAAQ;;;AAI5B,SAAS,oBACP,KACA,UACuB;AACvB,SAAQ,UAAR;EACE,KAAK,IACH,SAAO,QAAO,QAAQ;EACxB,KAAK,KACH,SAAO,QAAO,QAAQ;EACxB,KAAK,IACH,SAAO,QAAO,MAAM;EACtB,KAAK,KACH,SAAO,QAAO,OAAO;EACvB,KAAK,IACH,SAAO,QAAO,MAAM;EACtB,KAAK,KACH,SAAO,QAAO,OAAO;EACvB,KAAK,OACH,QAAO,iBAAiB,KAAK,GAAG;EAClC,KAAK,WACH,QAAO,IAAI,iBAAiB,KAAK,GAAG,CAAC;EACvC,KAAK,QACH,QAAO,iBAAiB,KAAK,IAAI;EACnC,KAAK,YACH,QAAO,IAAI,iBAAiB,KAAK,IAAI,CAAC;EACxC,KAAK,MAAM;AACT,UAAO,MAAM,QAAQ,IAAI,EAAE,8CAA8C;GACzE,MAAM,MAAM,IAAI,IAAI,IAAI;AACxB,WAAO,QAAO,IAAI,IAAI,IAAI;;EAE5B,KAAK,UAAU;AACb,UACE,MAAM,QAAQ,IAAI,EAClB,kDACD;GACD,MAAM,MAAM,IAAI,IAAI,IAAI;AACxB,WAAO,QAAO,CAAC,IAAI,IAAI,IAAI;;EAE7B,QAEE,OAAM,IAAI,MAAM,wBAAwB,WAAW;;;AAIzD,SAAS,IAAO,GAAwB;AACtC,SAAQ,QAAW,CAAC,EAAE,IAAI;;;;;;;;;;;AAY5B,SAAgB,iBAAiB,SAG/B;AACA,KAAI,CAAC,QACH,QAAO;EAAC,SAAS,KAAA;EAAW,mBAAmB;EAAM;AAEvD,SAAQ,QAAQ,MAAhB;EACE,KAAK,SACH,QAAO;GAAC;GAAS,mBAAmB;GAAM;EAC5C,KAAK,qBACH,QAAO;GAAC,SAAS,KAAA;GAAW,mBAAmB;GAAK;EACtD,KAAK;EACL,KAAK,MAAM;GACT,MAAM,wBAA+C,EAAE;GACvD,IAAI,oBAAoB;AACxB,QAAK,MAAM,QAAQ,QAAQ,YAAY;IACrC,MAAM,cAAc,iBAAiB,KAAK;AAG1C,QAAI,YAAY,YAAY,KAAA,KAAa,QAAQ,SAAS,KACxD,QAAO;KAAC,SAAS,KAAA;KAAW,mBAAmB;KAAK;AAEtD,wBAAoB,qBAAqB,YAAY;AACrD,QAAI,YAAY,QACd,uBAAsB,KAAK,YAAY,QAAQ;;AAGnD,UAAO;IACL,SAAS,kBAAkB;KACzB,MAAM,QAAQ;KACd,YAAY;KACb,CAAC;IACF;IACD;;EAEH,QACE,aAAY,QAAQ"}

package/out/zql/src/builder/like.js

@@ -1,53 +1,48 @@
 import { assertString } from "../../../shared/src/asserts.js";
+//#region ../zql/src/builder/like.ts
 function getLikePredicate(pattern, flags) {
-  const op = getLikeOp(String(pattern), flags);
-  return (lhs) => {
-    assertString(lhs);
-    return op(String(lhs));
-  };
+	const op = getLikeOp(String(pattern), flags);
+	return (lhs) => {
+		assertString(lhs);
+		return op(String(lhs));
+	};
 }
 function getLikeOp(pattern, flags) {
-  if (!/_|%|\\/.test(pattern)) {
-    if (flags === "i") {
-      const rhsLower = pattern.toLowerCase();
-      return (lhs) => lhs.toLowerCase() === rhsLower;
-    }
-    return (lhs) => lhs === pattern;
-  }
-  const re = patternToRegExp(pattern, flags);
-  return (lhs) => re.test(lhs);
+	if (!/_|%|\\/.test(pattern)) {
+		if (flags === "i") {
+			const rhsLower = pattern.toLowerCase();
+			return (lhs) => lhs.toLowerCase() === rhsLower;
+		}
+		return (lhs) => lhs === pattern;
+	}
+	const re = patternToRegExp(pattern, flags);
+	return (lhs) => re.test(lhs);
 }
-const specialCharsRe = /[$()*+.?[\]\\^{|}]/;
+var specialCharsRe = /[$()*+.?[\]\\^{|}]/;
 function patternToRegExp(source, flags = "") {
-  let pattern = "^";
-  for (let i = 0; i < source.length; i++) {
-    let c = source[i];
-    switch (c) {
-      case "%":
-        pattern += ".*";
-        break;
-      case "_":
-        pattern += ".";
-        break;
-      // @ts-expect-error fallthrough
-      case "\\":
-        if (i === source.length - 1) {
-          throw new Error("LIKE pattern must not end with escape character");
-        }
-        i++;
-        c = source[i];
-      // fall through
-      default:
-        if (specialCharsRe.test(c)) {
-          pattern += "\\";
-        }
-        pattern += c;
-        break;
-    }
-  }
-  return new RegExp(pattern + "$", flags + "m");
+	let pattern = "^";
+	for (let i = 0; i < source.length; i++) {
+		let c = source[i];
+		switch (c) {
+			case "%":
+				pattern += ".*";
+				break;
+			case "_":
+				pattern += ".";
+				break;
+			case "\\":
+				if (i === source.length - 1) throw new Error("LIKE pattern must not end with escape character");
+				i++;
+				c = source[i];
+			default:
+				if (specialCharsRe.test(c)) pattern += "\\";
+				pattern += c;
+				break;
+		}
+	}
+	return new RegExp(pattern + "$", flags + "m");
 }
-export {
-  getLikePredicate
-};
-//# sourceMappingURL=like.js.map
+//#endregion
+export { getLikePredicate };
+
+//# sourceMappingURL=like.js.map

package/out/zql/src/builder/like.js.map

@@ -1 +1 @@
-{"version":3,"file":"like.js","sources":["../../../../../zql/src/builder/like.ts"],"sourcesContent":["import {assertString} from '../../../shared/src/asserts.ts';\nimport type {NonNullValue, SimplePredicateNoNull} from './filter.ts';\n\nexport function getLikePredicate(\n  pattern: NonNullValue,\n  flags: 'i' | '',\n): SimplePredicateNoNull {\n  const op = getLikeOp(String(pattern), flags);\n  return (lhs: NonNullValue) => {\n    assertString(lhs);\n    return op(String(lhs));\n  };\n}\n\nfunction getLikeOp(pattern: string, flags: 'i' | ''): (lhs: string) => boolean {\n  // if lhs does not contain '%' or '_' then it is a simple string comparison.\n  // if it does contain '%' or '_' then it is a regex comparison.\n  // '%' is a wildcard for any number of characters\n  // '_' is a wildcard for a single character\n  // Postgres SQL allows escaping using `\\`.\n\n  if (!/_|%|\\\\/.test(pattern)) {\n    if (flags === 'i') {\n      const rhsLower = pattern.toLowerCase();\n      return (lhs: string) => lhs.toLowerCase() === rhsLower;\n    }\n    return (lhs: string) => lhs === pattern;\n  }\n  const re = patternToRegExp(pattern, flags);\n  return (lhs: string) => re.test(lhs);\n}\n\nconst specialCharsRe = /[$()*+.?[\\]\\\\^{|}]/;\n\nfunction patternToRegExp(source: string, flags: '' | 'i' = ''): RegExp {\n  // There are a few cases:\n  // % => .*\n  // _ => .\n  // \\x => \\x for any x except special regexp chars\n  // special regexp chars => \\special regexp chars\n  let pattern = '^';\n  for (let i = 0; i < source.length; i++) {\n    let c = source[i];\n    switch (c) {\n      case '%':\n        pattern += '.*';\n        break;\n      case '_':\n        pattern += '.';\n        break;\n\n      // @ts-expect-error fallthrough\n      case '\\\\':\n        if (i === source.length - 1) {\n          throw new Error('LIKE pattern must not end with escape character');\n        }\n        i++;\n        c = source[i];\n\n      // fall through\n      default:\n        if (specialCharsRe.test(c)) {\n          pattern += '\\\\';\n        }\n        pattern += c;\n\n        break;\n    }\n  }\n  return new RegExp(pattern + '$', flags + 'm');\n}\n"],"names":[],"mappings":";AAGO,SAAS,iBACd,SACA,OACuB;AACvB,QAAM,KAAK,UAAU,OAAO,OAAO,GAAG,KAAK;AAC3C,SAAO,CAAC,QAAsB;AAC5B,iBAAa,GAAG;AAChB,WAAO,GAAG,OAAO,GAAG,CAAC;AAAA,EACvB;AACF;AAEA,SAAS,UAAU,SAAiB,OAA2C;AAO7E,MAAI,CAAC,SAAS,KAAK,OAAO,GAAG;AAC3B,QAAI,UAAU,KAAK;AACjB,YAAM,WAAW,QAAQ,YAAA;AACzB,aAAO,CAAC,QAAgB,IAAI,YAAA,MAAkB;AAAA,IAChD;AACA,WAAO,CAAC,QAAgB,QAAQ;AAAA,EAClC;AACA,QAAM,KAAK,gBAAgB,SAAS,KAAK;AACzC,SAAO,CAAC,QAAgB,GAAG,KAAK,GAAG;AACrC;AAEA,MAAM,iBAAiB;AAEvB,SAAS,gBAAgB,QAAgB,QAAkB,IAAY;AAMrE,MAAI,UAAU;AACd,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,QAAI,IAAI,OAAO,CAAC;AAChB,YAAQ,GAAA;AAAA,MACN,KAAK;AACH,mBAAW;AACX;AAAA,MACF,KAAK;AACH,mBAAW;AACX;AAAA;AAAA,MAGF,KAAK;AACH,YAAI,MAAM,OAAO,SAAS,GAAG;AAC3B,gBAAM,IAAI,MAAM,iDAAiD;AAAA,QACnE;AACA;AACA,YAAI,OAAO,CAAC;AAAA;AAAA,MAGd;AACE,YAAI,eAAe,KAAK,CAAC,GAAG;AAC1B,qBAAW;AAAA,QACb;AACA,mBAAW;AAEX;AAAA,IAAA;AAAA,EAEN;AACA,SAAO,IAAI,OAAO,UAAU,KAAK,QAAQ,GAAG;AAC9C;"}
+{"version":3,"file":"like.js","names":[],"sources":["../../../../../zql/src/builder/like.ts"],"sourcesContent":["import {assertString} from '../../../shared/src/asserts.ts';\nimport type {NonNullValue, SimplePredicateNoNull} from './filter.ts';\n\nexport function getLikePredicate(\n  pattern: NonNullValue,\n  flags: 'i' | '',\n): SimplePredicateNoNull {\n  const op = getLikeOp(String(pattern), flags);\n  return (lhs: NonNullValue) => {\n    assertString(lhs);\n    return op(String(lhs));\n  };\n}\n\nfunction getLikeOp(pattern: string, flags: 'i' | ''): (lhs: string) => boolean {\n  // if lhs does not contain '%' or '_' then it is a simple string comparison.\n  // if it does contain '%' or '_' then it is a regex comparison.\n  // '%' is a wildcard for any number of characters\n  // '_' is a wildcard for a single character\n  // Postgres SQL allows escaping using `\\`.\n\n  if (!/_|%|\\\\/.test(pattern)) {\n    if (flags === 'i') {\n      const rhsLower = pattern.toLowerCase();\n      return (lhs: string) => lhs.toLowerCase() === rhsLower;\n    }\n    return (lhs: string) => lhs === pattern;\n  }\n  const re = patternToRegExp(pattern, flags);\n  return (lhs: string) => re.test(lhs);\n}\n\nconst specialCharsRe = /[$()*+.?[\\]\\\\^{|}]/;\n\nfunction patternToRegExp(source: string, flags: '' | 'i' = ''): RegExp {\n  // There are a few cases:\n  // % => .*\n  // _ => .\n  // \\x => \\x for any x except special regexp chars\n  // special regexp chars => \\special regexp chars\n  let pattern = '^';\n  for (let i = 0; i < source.length; i++) {\n    let c = source[i];\n    switch (c) {\n      case '%':\n        pattern += '.*';\n        break;\n      case '_':\n        pattern += '.';\n        break;\n\n      // @ts-expect-error fallthrough\n      case '\\\\':\n        if (i === source.length - 1) {\n          throw new Error('LIKE pattern must not end with escape character');\n        }\n        i++;\n        c = source[i];\n\n      // fall through\n      default:\n        if (specialCharsRe.test(c)) {\n          pattern += '\\\\';\n        }\n        pattern += c;\n\n        break;\n    }\n  }\n  return new RegExp(pattern + '$', flags + 'm');\n}\n"],"mappings":";;AAGA,SAAgB,iBACd,SACA,OACuB;CACvB,MAAM,KAAK,UAAU,OAAO,QAAQ,EAAE,MAAM;AAC5C,SAAQ,QAAsB;AAC5B,eAAa,IAAI;AACjB,SAAO,GAAG,OAAO,IAAI,CAAC;;;AAI1B,SAAS,UAAU,SAAiB,OAA2C;AAO7E,KAAI,CAAC,SAAS,KAAK,QAAQ,EAAE;AAC3B,MAAI,UAAU,KAAK;GACjB,MAAM,WAAW,QAAQ,aAAa;AACtC,WAAQ,QAAgB,IAAI,aAAa,KAAK;;AAEhD,UAAQ,QAAgB,QAAQ;;CAElC,MAAM,KAAK,gBAAgB,SAAS,MAAM;AAC1C,SAAQ,QAAgB,GAAG,KAAK,IAAI;;AAGtC,IAAM,iBAAiB;AAEvB,SAAS,gBAAgB,QAAgB,QAAkB,IAAY;CAMrE,IAAI,UAAU;AACd,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;EACtC,IAAI,IAAI,OAAO;AACf,UAAQ,GAAR;GACE,KAAK;AACH,eAAW;AACX;GACF,KAAK;AACH,eAAW;AACX;GAGF,KAAK;AACH,QAAI,MAAM,OAAO,SAAS,EACxB,OAAM,IAAI,MAAM,kDAAkD;AAEpE;AACA,QAAI,OAAO;GAGb;AACE,QAAI,eAAe,KAAK,EAAE,CACxB,YAAW;AAEb,eAAW;AAEX;;;AAGN,QAAO,IAAI,OAAO,UAAU,KAAK,QAAQ,IAAI"}

package/out/zql/src/error.js

@@ -1,10 +1,11 @@
-class NotImplementedError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "NotImplementedError";
-  }
-}
-export {
-  NotImplementedError
+//#region ../zql/src/error.ts
+var NotImplementedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "NotImplementedError";
+	}
 };
-//# sourceMappingURL=error.js.map
+//#endregion
+export { NotImplementedError };
+
+//# sourceMappingURL=error.js.map

package/out/zql/src/error.js.map

@@ -1 +1 @@
-{"version":3,"file":"error.js","sources":["../../../../zql/src/error.ts"],"sourcesContent":["export class NotImplementedError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'NotImplementedError';\n  }\n}\n\nexport type PlannerExceptionKind = 'max_flippable_joins';\n\nexport class PlannerException extends Error {\n  readonly kind: PlannerExceptionKind;\n\n  constructor(kind: PlannerExceptionKind, message: string) {\n    super(message);\n    this.name = 'PlannerException';\n    this.kind = kind;\n  }\n}\n"],"names":[],"mappings":"AAAO,MAAM,4BAA4B,MAAM;AAAA,EAC7C,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;"}
+{"version":3,"file":"error.js","names":[],"sources":["../../../../zql/src/error.ts"],"sourcesContent":["export class NotImplementedError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'NotImplementedError';\n  }\n}\n\nexport type PlannerExceptionKind = 'max_flippable_joins';\n\nexport class PlannerException extends Error {\n  readonly kind: PlannerExceptionKind;\n\n  constructor(kind: PlannerExceptionKind, message: string) {\n    super(message);\n    this.name = 'PlannerException';\n    this.kind = kind;\n  }\n}\n"],"mappings":";AAAA,IAAa,sBAAb,cAAyC,MAAM;CAC7C,YAAY,SAAiB;AAC3B,QAAM,QAAQ;AACd,OAAK,OAAO"}

package/out/zql/src/ivm/array-view.js

@@ -2,95 +2,93 @@ import { assert } from "../../../shared/src/asserts.js";
 import { emptyArray } from "../../../shared/src/sentinels.js";
 import { skipYields } from "./operator.js";
 import { applyChange } from "./view-apply-change.js";
-class ArrayView {
-  #input;
-  #listeners = /* @__PURE__ */ new Set();
-  #schema;
-  #format;
-  // Synthetic "root" entry that has a single "" relationship, so that we can
-  // treat all changes, including the root change, generically.
-  #root;
-  onDestroy;
-  #dirty = false;
-  #resultType = "unknown";
-  #error;
-  #updateTTL;
-  constructor(input, format, queryComplete, updateTTL) {
-    this.#input = input;
-    this.#schema = input.getSchema();
-    this.#format = format;
-    this.#updateTTL = updateTTL;
-    this.#root = { "": format.singular ? void 0 : [] };
-    input.setOutput(this);
-    if (queryComplete === true) {
-      this.#resultType = "complete";
-    } else if ("error" in queryComplete) {
-      this.#resultType = "error";
-      this.#error = queryComplete;
-    } else {
-      void queryComplete.then(() => {
-        this.#resultType = "complete";
-        this.#fireListeners();
-      }).catch((e) => {
-        this.#resultType = "error";
-        this.#error = e;
-        this.#fireListeners();
-      });
-    }
-    this.#hydrate();
-  }
-  get data() {
-    return this.#root[""];
-  }
-  addListener(listener) {
-    assert(!this.#listeners.has(listener), "Listener already registered");
-    this.#listeners.add(listener);
-    this.#fireListener(listener);
-    return () => {
-      this.#listeners.delete(listener);
-    };
-  }
-  #fireListeners() {
-    for (const listener of this.#listeners) {
-      this.#fireListener(listener);
-    }
-  }
-  #fireListener(listener) {
-    listener(this.data, this.#resultType, this.#error);
-  }
-  destroy() {
-    this.onDestroy?.();
-  }
-  #hydrate() {
-    this.#dirty = true;
-    for (const node of skipYields(this.#input.fetch({}))) {
-      applyChange(
-        this.#root,
-        { type: "add", node },
-        this.#schema,
-        "",
-        this.#format
-      );
-    }
-    this.flush();
-  }
-  push(change) {
-    this.#dirty = true;
-    applyChange(this.#root, change, this.#schema, "", this.#format);
-    return emptyArray;
-  }
-  flush() {
-    if (!this.#dirty) {
-      return;
-    }
-    this.#dirty = false;
-    this.#fireListeners();
-  }
-  updateTTL(ttl) {
-    this.#updateTTL(ttl);
-  }
-}
-export {
-  ArrayView
+//#region ../zql/src/ivm/array-view.ts
+/**
+* Implements a materialized view of the output of an operator.
+*
+* It might seem more efficient to use an immutable b-tree for the
+* materialization, but it's not so clear. Inserts in the middle are
+* asymptotically slower in an array, but can often be done with zero
+* allocations, where changes to the b-tree will often require several allocs.
+*
+* Also the plain array view is more convenient for consumers since you can dump
+* it into console to see what it is, rather than having to iterate it.
+*/
+var ArrayView = class {
+	#input;
+	#listeners = /* @__PURE__ */ new Set();
+	#schema;
+	#format;
+	#root;
+	onDestroy;
+	#dirty = false;
+	#resultType = "unknown";
+	#error;
+	#updateTTL;
+	constructor(input, format, queryComplete, updateTTL) {
+		this.#input = input;
+		this.#schema = input.getSchema();
+		this.#format = format;
+		this.#updateTTL = updateTTL;
+		this.#root = { "": format.singular ? void 0 : [] };
+		input.setOutput(this);
+		if (queryComplete === true) this.#resultType = "complete";
+		else if ("error" in queryComplete) {
+			this.#resultType = "error";
+			this.#error = queryComplete;
+		} else queryComplete.then(() => {
+			this.#resultType = "complete";
+			this.#fireListeners();
+		}).catch((e) => {
+			this.#resultType = "error";
+			this.#error = e;
+			this.#fireListeners();
+		});
+		this.#hydrate();
+	}
+	get data() {
+		return this.#root[""];
+	}
+	addListener(listener) {
+		assert(!this.#listeners.has(listener), "Listener already registered");
+		this.#listeners.add(listener);
+		this.#fireListener(listener);
+		return () => {
+			this.#listeners.delete(listener);
+		};
+	}
+	#fireListeners() {
+		for (const listener of this.#listeners) this.#fireListener(listener);
+	}
+	#fireListener(listener) {
+		listener(this.data, this.#resultType, this.#error);
+	}
+	destroy() {
+		this.onDestroy?.();
+	}
+	#hydrate() {
+		this.#dirty = true;
+		for (const node of skipYields(this.#input.fetch({}))) applyChange(this.#root, {
+			type: "add",
+			node
+		}, this.#schema, "", this.#format);
+		this.flush();
+	}
+	push(change) {
+		this.#dirty = true;
+		applyChange(this.#root, change, this.#schema, "", this.#format);
+		return emptyArray;
+	}
+	flush() {
+		if (!this.#dirty) return;
+		this.#dirty = false;
+		this.#fireListeners();
+	}
+	updateTTL(ttl) {
+		this.#updateTTL(ttl);
+	}
 };
-//# sourceMappingURL=array-view.js.map
+//#endregion
+export { ArrayView };
+
+//# sourceMappingURL=array-view.js.map

package/out/zql/src/ivm/array-view.js.map

@@ -1 +1 @@
-{"version":3,"file":"array-view.js","sources":["../../../../../zql/src/ivm/array-view.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Immutable} from '../../../shared/src/immutable.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport type {ErroredQuery} from '../../../zero-protocol/src/custom-queries.ts';\nimport type {TTL} from '../query/ttl.ts';\nimport type {Listener, ResultType, TypedView} from '../query/typed-view.ts';\nimport type {Change} from './change.ts';\nimport {skipYields, type Input, type Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {applyChange} from './view-apply-change.ts';\nimport type {Entry, Format, View} from './view.ts';\n\n/**\n * Implements a materialized view of the output of an operator.\n *\n * It might seem more efficient to use an immutable b-tree for the\n * materialization, but it's not so clear. Inserts in the middle are\n * asymptotically slower in an array, but can often be done with zero\n * allocations, where changes to the b-tree will often require several allocs.\n *\n * Also the plain array view is more convenient for consumers since you can dump\n * it into console to see what it is, rather than having to iterate it.\n */\nexport class ArrayView<V extends View> implements Output, TypedView<V> {\n  readonly #input: Input;\n  readonly #listeners = new Set<Listener<V>>();\n  readonly #schema: SourceSchema;\n  readonly #format: Format;\n\n  // Synthetic \"root\" entry that has a single \"\" relationship, so that we can\n  // treat all changes, including the root change, generically.\n  readonly #root: Entry;\n\n  onDestroy: (() => void) | undefined;\n\n  #dirty = false;\n  #resultType: ResultType = 'unknown';\n  #error: ErroredQuery | undefined;\n  readonly #updateTTL: (ttl: TTL) => void;\n\n  constructor(\n    input: Input,\n    format: Format,\n    queryComplete: true | ErroredQuery | Promise<true>,\n    updateTTL: (ttl: TTL) => void,\n  ) {\n    this.#input = input;\n    this.#schema = input.getSchema();\n    this.#format = format;\n    this.#updateTTL = updateTTL;\n    this.#root = {'': format.singular ? undefined : []};\n    input.setOutput(this);\n\n    if (queryComplete === true) {\n      this.#resultType = 'complete';\n    } else if ('error' in queryComplete) {\n      this.#resultType = 'error';\n      this.#error = queryComplete;\n    } else {\n      void queryComplete\n        .then(() => {\n          this.#resultType = 'complete';\n          this.#fireListeners();\n        })\n        .catch(e => {\n          this.#resultType = 'error';\n          this.#error = e;\n          this.#fireListeners();\n        });\n    }\n    this.#hydrate();\n  }\n\n  get data() {\n    return this.#root[''] as V;\n  }\n\n  addListener(listener: Listener<V>) {\n    assert(!this.#listeners.has(listener), 'Listener already registered');\n    this.#listeners.add(listener);\n\n    this.#fireListener(listener);\n\n    return () => {\n      this.#listeners.delete(listener);\n    };\n  }\n\n  #fireListeners() {\n    for (const listener of this.#listeners) {\n      this.#fireListener(listener);\n    }\n  }\n\n  #fireListener(listener: Listener<V>) {\n    listener(this.data as Immutable<V>, this.#resultType, this.#error);\n  }\n\n  destroy() {\n    this.onDestroy?.();\n  }\n\n  #hydrate() {\n    this.#dirty = true;\n    for (const node of skipYields(this.#input.fetch({}))) {\n      applyChange(\n        this.#root,\n        {type: 'add', node},\n        this.#schema,\n        '',\n        this.#format,\n      );\n    }\n    this.flush();\n  }\n\n  push(change: Change) {\n    this.#dirty = true;\n    applyChange(this.#root, change, this.#schema, '', this.#format);\n    return emptyArray;\n  }\n\n  flush() {\n    if (!this.#dirty) {\n      return;\n    }\n    this.#dirty = false;\n    this.#fireListeners();\n  }\n\n  updateTTL(ttl: TTL) {\n    this.#updateTTL(ttl);\n  }\n}\n"],"names":[],"mappings":";;;;AAuBO,MAAM,UAA0D;AAAA,EAC5D;AAAA,EACA,iCAAiB,IAAA;AAAA,EACjB;AAAA,EACA;AAAA;AAAA;AAAA,EAIA;AAAA,EAET;AAAA,EAEA,SAAS;AAAA,EACT,cAA0B;AAAA,EAC1B;AAAA,EACS;AAAA,EAET,YACE,OACA,QACA,eACA,WACA;AACA,SAAK,SAAS;AACd,SAAK,UAAU,MAAM,UAAA;AACrB,SAAK,UAAU;AACf,SAAK,aAAa;AAClB,SAAK,QAAQ,EAAC,IAAI,OAAO,WAAW,SAAY,GAAC;AACjD,UAAM,UAAU,IAAI;AAEpB,QAAI,kBAAkB,MAAM;AAC1B,WAAK,cAAc;AAAA,IACrB,WAAW,WAAW,eAAe;AACnC,WAAK,cAAc;AACnB,WAAK,SAAS;AAAA,IAChB,OAAO;AACL,WAAK,cACF,KAAK,MAAM;AACV,aAAK,cAAc;AACnB,aAAK,eAAA;AAAA,MACP,CAAC,EACA,MAAM,CAAA,MAAK;AACV,aAAK,cAAc;AACnB,aAAK,SAAS;AACd,aAAK,eAAA;AAAA,MACP,CAAC;AAAA,IACL;AACA,SAAK,SAAA;AAAA,EACP;AAAA,EAEA,IAAI,OAAO;AACT,WAAO,KAAK,MAAM,EAAE;AAAA,EACtB;AAAA,EAEA,YAAY,UAAuB;AACjC,WAAO,CAAC,KAAK,WAAW,IAAI,QAAQ,GAAG,6BAA6B;AACpE,SAAK,WAAW,IAAI,QAAQ;AAE5B,SAAK,cAAc,QAAQ;AAE3B,WAAO,MAAM;AACX,WAAK,WAAW,OAAO,QAAQ;AAAA,IACjC;AAAA,EACF;AAAA,EAEA,iBAAiB;AACf,eAAW,YAAY,KAAK,YAAY;AACtC,WAAK,cAAc,QAAQ;AAAA,IAC7B;AAAA,EACF;AAAA,EAEA,cAAc,UAAuB;AACnC,aAAS,KAAK,MAAsB,KAAK,aAAa,KAAK,MAAM;AAAA,EACnE;AAAA,EAEA,UAAU;AACR,SAAK,YAAA;AAAA,EACP;AAAA,EAEA,WAAW;AACT,SAAK,SAAS;AACd,eAAW,QAAQ,WAAW,KAAK,OAAO,MAAM,CAAA,CAAE,CAAC,GAAG;AACpD;AAAA,QACE,KAAK;AAAA,QACL,EAAC,MAAM,OAAO,KAAA;AAAA,QACd,KAAK;AAAA,QACL;AAAA,QACA,KAAK;AAAA,MAAA;AAAA,IAET;AACA,SAAK,MAAA;AAAA,EACP;AAAA,EAEA,KAAK,QAAgB;AACnB,SAAK,SAAS;AACd,gBAAY,KAAK,OAAO,QAAQ,KAAK,SAAS,IAAI,KAAK,OAAO;AAC9D,WAAO;AAAA,EACT;AAAA,EAEA,QAAQ;AACN,QAAI,CAAC,KAAK,QAAQ;AAChB;AAAA,IACF;AACA,SAAK,SAAS;AACd,SAAK,eAAA;AAAA,EACP;AAAA,EAEA,UAAU,KAAU;AAClB,SAAK,WAAW,GAAG;AAAA,EACrB;AACF;"}
+{"version":3,"file":"array-view.js","names":["#input","#listeners","#schema","#format","#root","#updateTTL","#resultType","#error","#fireListeners","#hydrate","#fireListener","#dirty"],"sources":["../../../../../zql/src/ivm/array-view.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Immutable} from '../../../shared/src/immutable.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport type {ErroredQuery} from '../../../zero-protocol/src/custom-queries.ts';\nimport type {TTL} from '../query/ttl.ts';\nimport type {Listener, ResultType, TypedView} from '../query/typed-view.ts';\nimport type {Change} from './change.ts';\nimport {skipYields, type Input, type Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {applyChange} from './view-apply-change.ts';\nimport type {Entry, Format, View} from './view.ts';\n\n/**\n * Implements a materialized view of the output of an operator.\n *\n * It might seem more efficient to use an immutable b-tree for the\n * materialization, but it's not so clear. Inserts in the middle are\n * asymptotically slower in an array, but can often be done with zero\n * allocations, where changes to the b-tree will often require several allocs.\n *\n * Also the plain array view is more convenient for consumers since you can dump\n * it into console to see what it is, rather than having to iterate it.\n */\nexport class ArrayView<V extends View> implements Output, TypedView<V> {\n  readonly #input: Input;\n  readonly #listeners = new Set<Listener<V>>();\n  readonly #schema: SourceSchema;\n  readonly #format: Format;\n\n  // Synthetic \"root\" entry that has a single \"\" relationship, so that we can\n  // treat all changes, including the root change, generically.\n  readonly #root: Entry;\n\n  onDestroy: (() => void) | undefined;\n\n  #dirty = false;\n  #resultType: ResultType = 'unknown';\n  #error: ErroredQuery | undefined;\n  readonly #updateTTL: (ttl: TTL) => void;\n\n  constructor(\n    input: Input,\n    format: Format,\n    queryComplete: true | ErroredQuery | Promise<true>,\n    updateTTL: (ttl: TTL) => void,\n  ) {\n    this.#input = input;\n    this.#schema = input.getSchema();\n    this.#format = format;\n    this.#updateTTL = updateTTL;\n    this.#root = {'': format.singular ? undefined : []};\n    input.setOutput(this);\n\n    if (queryComplete === true) {\n      this.#resultType = 'complete';\n    } else if ('error' in queryComplete) {\n      this.#resultType = 'error';\n      this.#error = queryComplete;\n    } else {\n      void queryComplete\n        .then(() => {\n          this.#resultType = 'complete';\n          this.#fireListeners();\n        })\n        .catch(e => {\n          this.#resultType = 'error';\n          this.#error = e;\n          this.#fireListeners();\n        });\n    }\n    this.#hydrate();\n  }\n\n  get data() {\n    return this.#root[''] as V;\n  }\n\n  addListener(listener: Listener<V>) {\n    assert(!this.#listeners.has(listener), 'Listener already registered');\n    this.#listeners.add(listener);\n\n    this.#fireListener(listener);\n\n    return () => {\n      this.#listeners.delete(listener);\n    };\n  }\n\n  #fireListeners() {\n    for (const listener of this.#listeners) {\n      this.#fireListener(listener);\n    }\n  }\n\n  #fireListener(listener: Listener<V>) {\n    listener(this.data as Immutable<V>, this.#resultType, this.#error);\n  }\n\n  destroy() {\n    this.onDestroy?.();\n  }\n\n  #hydrate() {\n    this.#dirty = true;\n    for (const node of skipYields(this.#input.fetch({}))) {\n      applyChange(\n        this.#root,\n        {type: 'add', node},\n        this.#schema,\n        '',\n        this.#format,\n      );\n    }\n    this.flush();\n  }\n\n  push(change: Change) {\n    this.#dirty = true;\n    applyChange(this.#root, change, this.#schema, '', this.#format);\n    return emptyArray;\n  }\n\n  flush() {\n    if (!this.#dirty) {\n      return;\n    }\n    this.#dirty = false;\n    this.#fireListeners();\n  }\n\n  updateTTL(ttl: TTL) {\n    this.#updateTTL(ttl);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAuBA,IAAa,YAAb,MAAuE;CACrE;CACA,6BAAsB,IAAI,KAAkB;CAC5C;CACA;CAIA;CAEA;CAEA,SAAS;CACT,cAA0B;CAC1B;CACA;CAEA,YACE,OACA,QACA,eACA,WACA;AACA,QAAA,QAAc;AACd,QAAA,SAAe,MAAM,WAAW;AAChC,QAAA,SAAe;AACf,QAAA,YAAkB;AAClB,QAAA,OAAa,EAAC,IAAI,OAAO,WAAW,KAAA,IAAY,EAAE,EAAC;AACnD,QAAM,UAAU,KAAK;AAErB,MAAI,kBAAkB,KACpB,OAAA,aAAmB;WACV,WAAW,eAAe;AACnC,SAAA,aAAmB;AACnB,SAAA,QAAc;QAET,eACF,WAAW;AACV,SAAA,aAAmB;AACnB,SAAA,eAAqB;IACrB,CACD,OAAM,MAAK;AACV,SAAA,aAAmB;AACnB,SAAA,QAAc;AACd,SAAA,eAAqB;IACrB;AAEN,QAAA,SAAe;;CAGjB,IAAI,OAAO;AACT,SAAO,MAAA,KAAW;;CAGpB,YAAY,UAAuB;AACjC,SAAO,CAAC,MAAA,UAAgB,IAAI,SAAS,EAAE,8BAA8B;AACrE,QAAA,UAAgB,IAAI,SAAS;AAE7B,QAAA,aAAmB,SAAS;AAE5B,eAAa;AACX,SAAA,UAAgB,OAAO,SAAS;;;CAIpC,iBAAiB;AACf,OAAK,MAAM,YAAY,MAAA,UACrB,OAAA,aAAmB,SAAS;;CAIhC,cAAc,UAAuB;AACnC,WAAS,KAAK,MAAsB,MAAA,YAAkB,MAAA,MAAY;;CAGpE,UAAU;AACR,OAAK,aAAa;;CAGpB,WAAW;AACT,QAAA,QAAc;AACd,OAAK,MAAM,QAAQ,WAAW,MAAA,MAAY,MAAM,EAAE,CAAC,CAAC,CAClD,aACE,MAAA,MACA;GAAC,MAAM;GAAO;GAAK,EACnB,MAAA,QACA,IACA,MAAA,OACD;AAEH,OAAK,OAAO;;CAGd,KAAK,QAAgB;AACnB,QAAA,QAAc;AACd,cAAY,MAAA,MAAY,QAAQ,MAAA,QAAc,IAAI,MAAA,OAAa;AAC/D,SAAO;;CAGT,QAAQ;AACN,MAAI,CAAC,MAAA,MACH;AAEF,QAAA,QAAc;AACd,QAAA,eAAqB;;CAGvB,UAAU,KAAU;AAClB,QAAA,UAAgB,IAAI"}

package/out/zql/src/ivm/constraint.js

@@ -1,91 +1,82 @@
 import { assert } from "../../../shared/src/asserts.js";
 import { stringCompare } from "../../../shared/src/string-compare.js";
 import { valuesEqual } from "./data.js";
+//#region ../zql/src/ivm/constraint.ts
 function constraintMatchesRow(constraint, row) {
-  for (const key in constraint) {
-    if (!valuesEqual(row[key], constraint[key])) {
-      return false;
-    }
-  }
-  return true;
+	for (const key in constraint) if (!valuesEqual(row[key], constraint[key])) return false;
+	return true;
 }
+/**
+* Constraints are compatible if:
+* 1. They do not have any keys in common
+* 2. They have keys in common, but the values for those keys are equal
+*/
 function constraintsAreCompatible(left, right) {
-  for (const key in left) {
-    if (key in right && !valuesEqual(left[key], right[key])) {
-      return false;
-    }
-  }
-  return true;
+	for (const key in left) if (key in right && !valuesEqual(left[key], right[key])) return false;
+	return true;
 }
 function constraintMatchesPrimaryKey(constraint, primary) {
-  return keyMatchesPrimaryKey(Object.keys(constraint), primary);
+	return keyMatchesPrimaryKey(Object.keys(constraint), primary);
 }
 function keyMatchesPrimaryKey(key, primary) {
-  const constraintKeys = [...key];
-  if (constraintKeys.length !== primary.length) {
-    return false;
-  }
-  constraintKeys.sort(stringCompare);
-  for (let i = 0; i < constraintKeys.length; i++) {
-    if (constraintKeys[i] !== primary[i]) {
-      return false;
-    }
-  }
-  return true;
+	const constraintKeys = [...key];
+	if (constraintKeys.length !== primary.length) return false;
+	constraintKeys.sort(stringCompare);
+	for (let i = 0; i < constraintKeys.length; i++) if (constraintKeys[i] !== primary[i]) return false;
+	return true;
 }
+/**
+* Pulls top level `and` components out of a condition tree.
+* The resulting array of simple conditions would match a superset of
+* values that the original condition would match.
+*
+* Examples:
+* a AND b OR c
+*
+* In this case we cannot pull anything because the `or` is at the top level.
+*
+* a AND b AND c
+* We can pull all three.
+*
+* a AND (b OR c)
+* We can only pull `a`.
+*/
 function pullSimpleAndComponents(condition) {
-  if (condition.type === "and") {
-    return condition.conditions.flatMap(pullSimpleAndComponents);
-  }
-  if (condition.type === "simple") {
-    return [condition];
-  }
-  if (condition.type === "or" && condition.conditions.length === 1) {
-    return pullSimpleAndComponents(condition.conditions[0]);
-  }
-  return [];
+	if (condition.type === "and") return condition.conditions.flatMap(pullSimpleAndComponents);
+	if (condition.type === "simple") return [condition];
+	if (condition.type === "or" && condition.conditions.length === 1) return pullSimpleAndComponents(condition.conditions[0]);
+	return [];
 }
+/**
+* Checks if the supplied filters constitute a primary key lookup.
+* If so, returns the constraint that would be used to look up the primary key.
+* If not, returns undefined.
+*/
 function primaryKeyConstraintFromFilters(condition, primary) {
-  if (condition === void 0) {
-    return void 0;
-  }
-  const conditions = pullSimpleAndComponents(condition);
-  if (conditions.length === 0) {
-    return void 0;
-  }
-  const ret = {};
-  for (const subCondition of conditions) {
-    if (subCondition.op === "=") {
-      const column = extractColumn(subCondition);
-      if (column !== void 0) {
-        if (!primary.includes(column.name)) {
-          continue;
-        }
-        ret[column.name] = column.value;
-      }
-    }
-  }
-  if (Object.keys(ret).length !== primary.length) {
-    return void 0;
-  }
-  return ret;
+	if (condition === void 0) return;
+	const conditions = pullSimpleAndComponents(condition);
+	if (conditions.length === 0) return;
+	const ret = {};
+	for (const subCondition of conditions) if (subCondition.op === "=") {
+		const column = extractColumn(subCondition);
+		if (column !== void 0) {
+			if (!primary.includes(column.name)) continue;
+			ret[column.name] = column.value;
+		}
+	}
+	if (Object.keys(ret).length !== primary.length) return;
+	return ret;
 }
 function extractColumn(condition) {
-  if (condition.left.type === "column") {
-    assert(
-      condition.right.type === "literal",
-      () => `extractColumn: expected right side to be literal, got ${condition.right.type}`
-    );
-    return { name: condition.left.name, value: condition.right.value };
-  }
-  return void 0;
+	if (condition.left.type === "column") {
+		assert(condition.right.type === "literal", () => `extractColumn: expected right side to be literal, got ${condition.right.type}`);
+		return {
+			name: condition.left.name,
+			value: condition.right.value
+		};
+	}
 }
-export {
-  constraintMatchesPrimaryKey,
-  constraintMatchesRow,
-  constraintsAreCompatible,
-  keyMatchesPrimaryKey,
-  primaryKeyConstraintFromFilters,
-  pullSimpleAndComponents
-};
-//# sourceMappingURL=constraint.js.map
+//#endregion
+export { constraintMatchesPrimaryKey, constraintMatchesRow, constraintsAreCompatible, primaryKeyConstraintFromFilters };
+
+//# sourceMappingURL=constraint.js.map

package/out/zql/src/ivm/constraint.js.map

@@ -1 +1 @@
-{"version":3,"file":"constraint.js","sources":["../../../../../zql/src/ivm/constraint.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {stringCompare} from '../../../shared/src/string-compare.ts';\nimport type {Writable} from '../../../shared/src/writable.ts';\nimport type {\n  Condition,\n  SimpleCondition,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport {valuesEqual} from './data.ts';\n\nexport type Constraint = {\n  readonly [key: string]: Value;\n};\n\nexport function constraintMatchesRow(\n  constraint: Constraint,\n  row: Row,\n): boolean {\n  for (const key in constraint) {\n    if (!valuesEqual(row[key], constraint[key])) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Constraints are compatible if:\n * 1. They do not have any keys in common\n * 2. They have keys in common, but the values for those keys are equal\n */\nexport function constraintsAreCompatible(\n  left: Constraint,\n  right: Constraint,\n): boolean {\n  for (const key in left) {\n    if (key in right && !valuesEqual(left[key], right[key])) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function constraintMatchesPrimaryKey(\n  constraint: Constraint,\n  primary: PrimaryKey,\n): boolean {\n  return keyMatchesPrimaryKey(Object.keys(constraint), primary);\n}\n\nexport function keyMatchesPrimaryKey(\n  key: Iterable<string>,\n  primary: PrimaryKey,\n): boolean {\n  const constraintKeys = [...key];\n\n  if (constraintKeys.length !== primary.length) {\n    return false;\n  }\n\n  // Primary key is always sorted\n  // Constraint does not have to be sorted\n  constraintKeys.sort(stringCompare);\n\n  for (let i = 0; i < constraintKeys.length; i++) {\n    if (constraintKeys[i] !== primary[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Pulls top level `and` components out of a condition tree.\n * The resulting array of simple conditions would match a superset of\n * values that the original condition would match.\n *\n * Examples:\n * a AND b OR c\n *\n * In this case we cannot pull anything because the `or` is at the top level.\n *\n * a AND b AND c\n * We can pull all three.\n *\n * a AND (b OR c)\n * We can only pull `a`.\n */\nexport function pullSimpleAndComponents(\n  condition: Condition,\n): SimpleCondition[] {\n  if (condition.type === 'and') {\n    return condition.conditions.flatMap(pullSimpleAndComponents);\n  }\n\n  if (condition.type === 'simple') {\n    return [condition];\n  }\n\n  if (condition.type === 'or' && condition.conditions.length === 1) {\n    return pullSimpleAndComponents(condition.conditions[0]);\n  }\n\n  return [];\n}\n\n/**\n * Checks if the supplied filters constitute a primary key lookup.\n * If so, returns the constraint that would be used to look up the primary key.\n * If not, returns undefined.\n */\nexport function primaryKeyConstraintFromFilters(\n  condition: Condition | undefined,\n  primary: PrimaryKey,\n): Constraint | undefined {\n  if (condition === undefined) {\n    return undefined;\n  }\n\n  const conditions = pullSimpleAndComponents(condition);\n  if (conditions.length === 0) {\n    return undefined;\n  }\n\n  const ret: Writable<Constraint> = {};\n  for (const subCondition of conditions) {\n    if (subCondition.op === '=') {\n      const column = extractColumn(subCondition);\n      if (column !== undefined) {\n        if (!primary.includes(column.name)) {\n          continue;\n        }\n        ret[column.name] = column.value;\n      }\n    }\n  }\n\n  if (Object.keys(ret).length !== primary.length) {\n    return undefined;\n  }\n\n  return ret;\n}\n\nfunction extractColumn(\n  condition: SimpleCondition,\n): {name: string; value: Value} | undefined {\n  if (condition.left.type === 'column') {\n    assert(\n      condition.right.type === 'literal',\n      () =>\n        `extractColumn: expected right side to be literal, got ${condition.right.type}`,\n    );\n    return {name: condition.left.name, value: condition.right.value};\n  }\n\n  return undefined;\n}\n\ndeclare const TESTING: boolean;\n\nexport class SetOfConstraint {\n  #data: Constraint[] = [];\n\n  constructor() {\n    // Only used in testing\n    assert(TESTING, 'SetOfConstraint is only available in testing');\n  }\n\n  #indexOf(value: Constraint): number {\n    return this.#data.findIndex(v => constraintEquals(v, value));\n  }\n\n  has(value: Constraint): boolean {\n    return this.#indexOf(value) !== -1;\n  }\n\n  add(value: Constraint): this {\n    if (!this.has(value)) {\n      this.#data.push(value);\n    }\n    return this;\n  }\n}\n\nfunction constraintEquals(a: Constraint, b: Constraint): boolean {\n  const aEntries = Object.entries(a);\n  const bEntries = Object.entries(b);\n  if (aEntries.length !== bEntries.length) {\n    return false;\n  }\n  for (let i = 0; i < aEntries.length; i++) {\n    if (\n      aEntries[i][0] !== bEntries[i][0] ||\n      !valuesEqual(aEntries[i][1], bEntries[i][1])\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n"],"names":[],"mappings":";;;AAeO,SAAS,qBACd,YACA,KACS;AACT,aAAW,OAAO,YAAY;AAC5B,QAAI,CAAC,YAAY,IAAI,GAAG,GAAG,WAAW,GAAG,CAAC,GAAG;AAC3C,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAOO,SAAS,yBACd,MACA,OACS;AACT,aAAW,OAAO,MAAM;AACtB,QAAI,OAAO,SAAS,CAAC,YAAY,KAAK,GAAG,GAAG,MAAM,GAAG,CAAC,GAAG;AACvD,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAEO,SAAS,4BACd,YACA,SACS;AACT,SAAO,qBAAqB,OAAO,KAAK,UAAU,GAAG,OAAO;AAC9D;AAEO,SAAS,qBACd,KACA,SACS;AACT,QAAM,iBAAiB,CAAC,GAAG,GAAG;AAE9B,MAAI,eAAe,WAAW,QAAQ,QAAQ;AAC5C,WAAO;AAAA,EACT;AAIA,iBAAe,KAAK,aAAa;AAEjC,WAAS,IAAI,GAAG,IAAI,eAAe,QAAQ,KAAK;AAC9C,QAAI,eAAe,CAAC,MAAM,QAAQ,CAAC,GAAG;AACpC,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAkBO,SAAS,wBACd,WACmB;AACnB,MAAI,UAAU,SAAS,OAAO;AAC5B,WAAO,UAAU,WAAW,QAAQ,uBAAuB;AAAA,EAC7D;AAEA,MAAI,UAAU,SAAS,UAAU;AAC/B,WAAO,CAAC,SAAS;AAAA,EACnB;AAEA,MAAI,UAAU,SAAS,QAAQ,UAAU,WAAW,WAAW,GAAG;AAChE,WAAO,wBAAwB,UAAU,WAAW,CAAC,CAAC;AAAA,EACxD;AAEA,SAAO,CAAA;AACT;AAOO,SAAS,gCACd,WACA,SACwB;AACxB,MAAI,cAAc,QAAW;AAC3B,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,wBAAwB,SAAS;AACpD,MAAI,WAAW,WAAW,GAAG;AAC3B,WAAO;AAAA,EACT;AAEA,QAAM,MAA4B,CAAA;AAClC,aAAW,gBAAgB,YAAY;AACrC,QAAI,aAAa,OAAO,KAAK;AAC3B,YAAM,SAAS,cAAc,YAAY;AACzC,UAAI,WAAW,QAAW;AACxB,YAAI,CAAC,QAAQ,SAAS,OAAO,IAAI,GAAG;AAClC;AAAA,QACF;AACA,YAAI,OAAO,IAAI,IAAI,OAAO;AAAA,MAC5B;AAAA,IACF;AAAA,EACF;AAEA,MAAI,OAAO,KAAK,GAAG,EAAE,WAAW,QAAQ,QAAQ;AAC9C,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEA,SAAS,cACP,WAC0C;AAC1C,MAAI,UAAU,KAAK,SAAS,UAAU;AACpC;AAAA,MACE,UAAU,MAAM,SAAS;AAAA,MACzB,MACE,yDAAyD,UAAU,MAAM,IAAI;AAAA,IAAA;AAEjF,WAAO,EAAC,MAAM,UAAU,KAAK,MAAM,OAAO,UAAU,MAAM,MAAA;AAAA,EAC5D;AAEA,SAAO;AACT;"}
+{"version":3,"file":"constraint.js","names":["#data","#indexOf"],"sources":["../../../../../zql/src/ivm/constraint.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {stringCompare} from '../../../shared/src/string-compare.ts';\nimport type {Writable} from '../../../shared/src/writable.ts';\nimport type {\n  Condition,\n  SimpleCondition,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport {valuesEqual} from './data.ts';\n\nexport type Constraint = {\n  readonly [key: string]: Value;\n};\n\nexport function constraintMatchesRow(\n  constraint: Constraint,\n  row: Row,\n): boolean {\n  for (const key in constraint) {\n    if (!valuesEqual(row[key], constraint[key])) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Constraints are compatible if:\n * 1. They do not have any keys in common\n * 2. They have keys in common, but the values for those keys are equal\n */\nexport function constraintsAreCompatible(\n  left: Constraint,\n  right: Constraint,\n): boolean {\n  for (const key in left) {\n    if (key in right && !valuesEqual(left[key], right[key])) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function constraintMatchesPrimaryKey(\n  constraint: Constraint,\n  primary: PrimaryKey,\n): boolean {\n  return keyMatchesPrimaryKey(Object.keys(constraint), primary);\n}\n\nexport function keyMatchesPrimaryKey(\n  key: Iterable<string>,\n  primary: PrimaryKey,\n): boolean {\n  const constraintKeys = [...key];\n\n  if (constraintKeys.length !== primary.length) {\n    return false;\n  }\n\n  // Primary key is always sorted\n  // Constraint does not have to be sorted\n  constraintKeys.sort(stringCompare);\n\n  for (let i = 0; i < constraintKeys.length; i++) {\n    if (constraintKeys[i] !== primary[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Pulls top level `and` components out of a condition tree.\n * The resulting array of simple conditions would match a superset of\n * values that the original condition would match.\n *\n * Examples:\n * a AND b OR c\n *\n * In this case we cannot pull anything because the `or` is at the top level.\n *\n * a AND b AND c\n * We can pull all three.\n *\n * a AND (b OR c)\n * We can only pull `a`.\n */\nexport function pullSimpleAndComponents(\n  condition: Condition,\n): SimpleCondition[] {\n  if (condition.type === 'and') {\n    return condition.conditions.flatMap(pullSimpleAndComponents);\n  }\n\n  if (condition.type === 'simple') {\n    return [condition];\n  }\n\n  if (condition.type === 'or' && condition.conditions.length === 1) {\n    return pullSimpleAndComponents(condition.conditions[0]);\n  }\n\n  return [];\n}\n\n/**\n * Checks if the supplied filters constitute a primary key lookup.\n * If so, returns the constraint that would be used to look up the primary key.\n * If not, returns undefined.\n */\nexport function primaryKeyConstraintFromFilters(\n  condition: Condition | undefined,\n  primary: PrimaryKey,\n): Constraint | undefined {\n  if (condition === undefined) {\n    return undefined;\n  }\n\n  const conditions = pullSimpleAndComponents(condition);\n  if (conditions.length === 0) {\n    return undefined;\n  }\n\n  const ret: Writable<Constraint> = {};\n  for (const subCondition of conditions) {\n    if (subCondition.op === '=') {\n      const column = extractColumn(subCondition);\n      if (column !== undefined) {\n        if (!primary.includes(column.name)) {\n          continue;\n        }\n        ret[column.name] = column.value;\n      }\n    }\n  }\n\n  if (Object.keys(ret).length !== primary.length) {\n    return undefined;\n  }\n\n  return ret;\n}\n\nfunction extractColumn(\n  condition: SimpleCondition,\n): {name: string; value: Value} | undefined {\n  if (condition.left.type === 'column') {\n    assert(\n      condition.right.type === 'literal',\n      () =>\n        `extractColumn: expected right side to be literal, got ${condition.right.type}`,\n    );\n    return {name: condition.left.name, value: condition.right.value};\n  }\n\n  return undefined;\n}\n\ndeclare const TESTING: boolean;\n\nexport class SetOfConstraint {\n  #data: Constraint[] = [];\n\n  constructor() {\n    // Only used in testing\n    assert(TESTING, 'SetOfConstraint is only available in testing');\n  }\n\n  #indexOf(value: Constraint): number {\n    return this.#data.findIndex(v => constraintEquals(v, value));\n  }\n\n  has(value: Constraint): boolean {\n    return this.#indexOf(value) !== -1;\n  }\n\n  add(value: Constraint): this {\n    if (!this.has(value)) {\n      this.#data.push(value);\n    }\n    return this;\n  }\n}\n\nfunction constraintEquals(a: Constraint, b: Constraint): boolean {\n  const aEntries = Object.entries(a);\n  const bEntries = Object.entries(b);\n  if (aEntries.length !== bEntries.length) {\n    return false;\n  }\n  for (let i = 0; i < aEntries.length; i++) {\n    if (\n      aEntries[i][0] !== bEntries[i][0] ||\n      !valuesEqual(aEntries[i][1], bEntries[i][1])\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n"],"mappings":";;;;AAeA,SAAgB,qBACd,YACA,KACS;AACT,MAAK,MAAM,OAAO,WAChB,KAAI,CAAC,YAAY,IAAI,MAAM,WAAW,KAAK,CACzC,QAAO;AAGX,QAAO;;;;;;;AAQT,SAAgB,yBACd,MACA,OACS;AACT,MAAK,MAAM,OAAO,KAChB,KAAI,OAAO,SAAS,CAAC,YAAY,KAAK,MAAM,MAAM,KAAK,CACrD,QAAO;AAGX,QAAO;;AAGT,SAAgB,4BACd,YACA,SACS;AACT,QAAO,qBAAqB,OAAO,KAAK,WAAW,EAAE,QAAQ;;AAG/D,SAAgB,qBACd,KACA,SACS;CACT,MAAM,iBAAiB,CAAC,GAAG,IAAI;AAE/B,KAAI,eAAe,WAAW,QAAQ,OACpC,QAAO;AAKT,gBAAe,KAAK,cAAc;AAElC,MAAK,IAAI,IAAI,GAAG,IAAI,eAAe,QAAQ,IACzC,KAAI,eAAe,OAAO,QAAQ,GAChC,QAAO;AAGX,QAAO;;;;;;;;;;;;;;;;;;AAmBT,SAAgB,wBACd,WACmB;AACnB,KAAI,UAAU,SAAS,MACrB,QAAO,UAAU,WAAW,QAAQ,wBAAwB;AAG9D,KAAI,UAAU,SAAS,SACrB,QAAO,CAAC,UAAU;AAGpB,KAAI,UAAU,SAAS,QAAQ,UAAU,WAAW,WAAW,EAC7D,QAAO,wBAAwB,UAAU,WAAW,GAAG;AAGzD,QAAO,EAAE;;;;;;;AAQX,SAAgB,gCACd,WACA,SACwB;AACxB,KAAI,cAAc,KAAA,EAChB;CAGF,MAAM,aAAa,wBAAwB,UAAU;AACrD,KAAI,WAAW,WAAW,EACxB;CAGF,MAAM,MAA4B,EAAE;AACpC,MAAK,MAAM,gBAAgB,WACzB,KAAI,aAAa,OAAO,KAAK;EAC3B,MAAM,SAAS,cAAc,aAAa;AAC1C,MAAI,WAAW,KAAA,GAAW;AACxB,OAAI,CAAC,QAAQ,SAAS,OAAO,KAAK,CAChC;AAEF,OAAI,OAAO,QAAQ,OAAO;;;AAKhC,KAAI,OAAO,KAAK,IAAI,CAAC,WAAW,QAAQ,OACtC;AAGF,QAAO;;AAGT,SAAS,cACP,WAC0C;AAC1C,KAAI,UAAU,KAAK,SAAS,UAAU;AACpC,SACE,UAAU,MAAM,SAAS,iBAEvB,yDAAyD,UAAU,MAAM,OAC5E;AACD,SAAO;GAAC,MAAM,UAAU,KAAK;GAAM,OAAO,UAAU,MAAM;GAAM"}