@enspirit/bmg-js 1.0.2 → 1.1.0

package/dist/bmg.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"bmg.cjs","sources":["../src/support/toPredicateFunc.ts","../src/Relation/Memory.ts","../src/operators/isRelation.ts","../src/operators/_helpers.ts","../src/operators/restrict.ts","../src/operators/exclude.ts","../src/operators/constants.ts","../src/operators/rename.ts","../src/operators/prefix.ts","../src/operators/suffix.ts","../src/operators/project.ts","../src/operators/allbut.ts","../src/operators/extend.ts","../src/operators/union.ts","../src/operators/minus.ts","../src/operators/intersect.ts","../src/operators/matching.ts","../src/operators/not_matching.ts","../src/operators/join.ts","../src/operators/left_join.ts","../src/operators/cross_product.ts","../src/operators/image.ts","../src/operators/summarize.ts","../src/operators/group.ts","../src/operators/ungroup.ts","../src/operators/wrap.ts","../src/operators/unwrap.ts","../src/operators/autowrap.ts","../src/operators/transform.ts","../src/operators/isEqual.ts","../src/operators/one.ts","../src/operators/yByX.ts","../src/index.ts","../src/lib-definitions.ts"],"sourcesContent":["import { Predicate, PredicateFunc, Tuple } from '../types';\n\nexport const toPredicateFunc = (p: Predicate): PredicateFunc => {\n  if (typeof(p) === 'function') {\n    return p as PredicateFunc;\n  } else {\n    const expected = p as Tuple;\n    return (t: Tuple) => {\n      return Object.keys(expected).every(k => t[k] === expected[k])\n    }\n  }\n}\n","import {\n  allbut,\n  autowrap,\n  constants,\n  cross_product,\n  exclude,\n  extend,\n  group,\n  image,\n  intersect,\n  isEqual,\n  join,\n  left_join,\n  matching,\n  minus,\n  not_matching,\n  one,\n  prefix,\n  project,\n  rename,\n  restrict,\n  suffix,\n  summarize,\n  where,\n  transform,\n  ungroup,\n  union,\n  unwrap,\n  wrap,\n  yByX,\n} from \"../operators\";\nimport type {\n  AttrName,\n  AutowrapOptions,\n  Relation,\n  RelationOperand,\n  Transformation,\n  Tuple,\n  TypedPredicate,\n  TypedExtension,\n  RenameMap,\n  Renamed,\n  Prefixed,\n  Suffixed,\n  Joined,\n  LeftJoined,\n  Wrapped,\n  Unwrapped,\n  Ungrouped,\n  AggregatorResults,\n  TypedJoinKeysArray,\n  TypedJoinKeysObject,\n} from \"../types\";\n\n/**\n * In-memory implementation of the Relation interface.\n *\n * @typeParam T - The tuple type for this relation. Defaults to `Tuple` (Record<string, unknown>).\n */\nexport class MemoryRelation<T = Tuple> implements Relation<T> {\n\n  constructor(private tuples: T[]) {\n    this.tuples = tuples;\n  }\n\n  // === Type-preserving operators ===\n\n  restrict(p: TypedPredicate<T>): Relation<T> {\n    return restrict(this as any, p as any) as unknown as Relation<T>;\n  }\n\n  where(p: TypedPredicate<T>): Relation<T> {\n    return where(this as any, p as any) as unknown as Relation<T>;\n  }\n\n  exclude(p: TypedPredicate<T>): Relation<T> {\n    return exclude(this as any, p as any) as unknown as Relation<T>;\n  }\n\n  // === Projection operators ===\n\n  project<K extends keyof T>(attrs: K[]): Relation<Pick<T, K>> {\n    return project(this as any, attrs as AttrName[]) as unknown as Relation<Pick<T, K>>;\n  }\n\n  allbut<K extends keyof T>(attrs: K[]): Relation<Omit<T, K>> {\n    return allbut(this as any, attrs as AttrName[]) as unknown as Relation<Omit<T, K>>;\n  }\n\n  // === Extension operators ===\n\n  extend<E extends Record<string, unknown>>(e: TypedExtension<T, E>): Relation<T & E> {\n    return extend(this as any, e as any) as unknown as Relation<T & E>;\n  }\n\n  constants<C extends Tuple>(consts: C): Relation<T & C> {\n    return constants(this as any, consts) as unknown as Relation<T & C>;\n  }\n\n  // === Rename operators ===\n\n  rename<R extends RenameMap<T>>(r: R): Relation<Renamed<T, R>> {\n    return rename(this as any, r as any) as unknown as Relation<Renamed<T, R>>;\n  }\n\n  prefix<P extends string, Ex extends keyof T = never>(pfx: P, options?: { except?: Ex[] }): Relation<Prefixed<T, P, Ex>> {\n    return prefix(this as any, pfx, options as any) as unknown as Relation<Prefixed<T, P, Ex>>;\n  }\n\n  suffix<S extends string, Ex extends keyof T = never>(sfx: S, options?: { except?: Ex[] }): Relation<Suffixed<T, S, Ex>> {\n    return suffix(this as any, sfx, options as any) as unknown as Relation<Suffixed<T, S, Ex>>;\n  }\n\n  // === Set operators ===\n\n  union(right: RelationOperand<T>): Relation<T> {\n    return union(this as any, right as any) as unknown as Relation<T>;\n  }\n\n  minus(right: RelationOperand<T>): Relation<T> {\n    return minus(this as any, right as any) as unknown as Relation<T>;\n  }\n\n  intersect(right: RelationOperand<T>): Relation<T> {\n    return intersect(this as any, right as any) as unknown as Relation<T>;\n  }\n\n  // === Semi-join operators ===\n\n  matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T> {\n    return matching(this as any, right as any, keys as any) as unknown as Relation<T>;\n  }\n\n  not_matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T> {\n    return not_matching(this as any, right as any, keys as any) as unknown as Relation<T>;\n  }\n\n  // === Join operators ===\n\n  join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<Joined<T, R>> {\n    return join(this as any, right as any, keys as any) as unknown as Relation<Joined<T, R>>;\n  }\n\n  left_join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<LeftJoined<T, R>> {\n    return left_join(this as any, right as any, keys as any) as unknown as Relation<LeftJoined<T, R>>;\n  }\n\n  cross_product<R>(right: RelationOperand<R>): Relation<T & R> {\n    return cross_product(this as any, right as any) as unknown as Relation<T & R>;\n  }\n\n  cross_join<R>(right: RelationOperand<R>): Relation<T & R> {\n    return cross_product(this as any, right as any) as unknown as Relation<T & R>;\n  }\n\n  // === Nesting operators ===\n\n  image<R, As extends string>(right: RelationOperand<R>, as: As, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T & Record<As, Relation<Omit<R, keyof T & keyof R>>>> {\n    return image(this as any, right as any, as, keys as any) as unknown as Relation<T & Record<As, Relation<Omit<R, keyof T & keyof R>>>>;\n  }\n\n  group<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Omit<T, K> & Record<As, Relation<Pick<T, K>>>> {\n    return group(this as any, attrs as AttrName[], as) as unknown as Relation<Omit<T, K> & Record<As, Relation<Pick<T, K>>>>;\n  }\n\n  ungroup<K extends keyof T>(attr: K): Relation<Ungrouped<T, K>> {\n    return ungroup(this as any, attr as AttrName) as unknown as Relation<Ungrouped<T, K>>;\n  }\n\n  wrap<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Wrapped<T, K, As>> {\n    return wrap(this as any, attrs as AttrName[], as) as unknown as Relation<Wrapped<T, K, As>>;\n  }\n\n  unwrap<K extends keyof T>(attr: K): Relation<Unwrapped<T, K>> {\n    return unwrap(this as any, attr as AttrName) as unknown as Relation<Unwrapped<T, K>>;\n  }\n\n  // === Aggregation ===\n\n  summarize<By extends keyof T, Aggs extends Record<string, unknown>>(by: By[], aggs: Aggs): Relation<Pick<T, By> & AggregatorResults<Aggs>> {\n    return summarize(this as any, by as AttrName[], aggs as any) as unknown as Relation<Pick<T, By> & AggregatorResults<Aggs>>;\n  }\n\n  // === Transform ===\n\n  transform(t: Transformation): Relation<T> {\n    return transform(this as any, t) as unknown as Relation<T>;\n  }\n\n  // === Dynamic ===\n\n  autowrap(options?: AutowrapOptions): Relation<Tuple> {\n    return autowrap(this as any, options) as Relation<Tuple>;\n  }\n\n  // === Non-relational ===\n\n  one(): T {\n    return one(this as any) as T;\n  }\n\n  toArray(): T[] {\n    return this.tuples;\n  }\n\n  yByX<Y extends keyof T, X extends keyof T>(y: Y, x: X): Record<T[X] & PropertyKey, T[Y]> {\n    return yByX(this as any, y as AttrName, x as AttrName) as Record<T[X] & PropertyKey, T[Y]>;\n  }\n\n  isEqual(right: any): boolean {\n    return isEqual(this as any, right as any);\n  }\n\n}\n","import { MemoryRelation } from \"@/Relation\";\n\nexport const isRelation = (op) => {\n  return op != null && op.constructor === MemoryRelation;\n}\n","import { OperationalOperand, Relation, RelationOperand, Renaming, RenamingFunc, Tuple, JoinKeys, AttrName } from \"@/types\";\nimport { MemoryRelation } from '@/Relation';\nimport { isRelation } from \"./isRelation\";\n\nconst valueKey = (value: unknown): unknown => {\n  if (isRelation(value)) {\n    // For nested relations, convert to sorted array of tuple keys for comparison\n    const tuples = (value as Relation).toArray();\n    const keys = tuples.map(t => tupleKey(t)).sort();\n    return keys;\n  }\n  return value;\n}\n\n/**\n * Generates a unique string key for a tuple, used for equality comparison and deduplication.\n * Handles nested relations by converting them to sorted tuple keys.\n *\n * @example\n * tupleKey({ name: 'Alice', age: 30 })\n * // => '[[\"age\",30],[\"name\",\"Alice\"]]'\n *\n * @example\n * tupleKey({ id: 1, items: Bmg([{ x: 1 }, { x: 2 }]) })\n * // => '[[\"id\",1],[\"items\",[...]]]' (nested relation converted to sorted keys)\n */\nexport const tupleKey = (tuple: Tuple): string => {\n  const entries = Object.entries(tuple).map(([k, v]) => [k, valueKey(v)]);\n  return JSON.stringify(entries.sort(([a], [b]) => (a as string).localeCompare(b as string)));\n}\n\n/**\n * Removes duplicate tuples from an array, preserving order of first occurrence.\n * Uses tupleKey() for equality comparison.\n *\n * @example\n * deduplicate([\n *   { id: 1, name: 'Alice' },\n *   { id: 2, name: 'Bob' },\n *   { id: 1, name: 'Alice' },  // duplicate\n * ])\n * // => [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]\n */\nexport const deduplicate = (tuples: Tuple[]): Tuple[] => {\n  const seen = new Set<string>();\n  const result: Tuple[] = [];\n  for (const tuple of tuples) {\n    const key = tupleKey(tuple);\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(tuple);\n    }\n  }\n  return result;\n}\n\n/**\n * Converts a RelationOperand (Relation or Tuple[]) to an OperationalOperand\n * that provides a uniform interface for iteration and output.\n *\n * @example\n * // With array input, output remains array\n * const op = toOperationalOperand([{ id: 1 }]);\n * [...op.tuples()];        // => [{ id: 1 }]\n * op.output([{ id: 2 }]);  // => [{ id: 2 }]\n *\n * @example\n * // With Relation input, output is a new Relation\n * const op = toOperationalOperand(Bmg([{ id: 1 }]));\n * [...op.tuples()];        // => [{ id: 1 }]\n * op.output([{ id: 2 }]);  // => Bmg([{ id: 2 }])\n */\nexport const toOperationalOperand = (operand: RelationOperand): OperationalOperand => {\n  if (Array.isArray(operand)) {\n    return {\n      tuples: () => operand,\n      output: (tuples) => tuples,\n    };\n  } else if (isRelation(operand)) {\n    return {\n      tuples: () => (operand as Relation).toArray(),\n      output: (tuples) => new MemoryRelation(tuples),\n    };\n  } else {\n    throw `Unable to iterate ${operand}`\n  }\n}\n\n/**\n * Converts a Renaming (object or function) to a RenamingFunc.\n *\n * @example\n * // Object renaming\n * const fn = toRenamingFunc({ name: 'fullName', age: 'years' });\n * fn('name');  // => 'fullName'\n * fn('age');   // => 'years'\n * fn('other'); // => 'other' (unchanged)\n *\n * @example\n * // Function renaming (passed through)\n * const fn = toRenamingFunc(attr => attr.toUpperCase());\n * fn('name'); // => 'NAME'\n */\nexport const toRenamingFunc = (renaming: Renaming): RenamingFunc => {\n  if (typeof(renaming) === 'function') {\n    return renaming;\n  } else {\n    return (attr) => renaming[attr] || attr;\n  }\n}\n\nexport const error = (msg: string) => {\n  throw(msg);\n}\n\n// Join helpers\n\n/**\n * Finds attribute names that exist in both left and right tuple arrays.\n * Used for natural joins when no explicit keys are provided.\n *\n * @example\n * const left = [{ id: 1, name: 'Alice', city: 'NYC' }];\n * const right = [{ city: 'NYC', country: 'USA' }];\n * getCommonAttrs(left, right);\n * // => ['city']\n *\n * @example\n * const left = [{ a: 1, b: 2 }];\n * const right = [{ b: 2, c: 3 }];\n * getCommonAttrs(left, right);\n * // => ['b']\n */\nexport const getCommonAttrs = (left: Tuple[], right: Tuple[]): AttrName[] => {\n  if (left.length === 0 || right.length === 0) return [];\n  const leftAttrs = new Set(Object.keys(left[0]));\n  const rightAttrs = Object.keys(right[0]);\n  return rightAttrs.filter(attr => leftAttrs.has(attr));\n}\n\n/**\n * Normalizes JoinKeys to a Record<AttrName, AttrName> mapping left attrs to right attrs.\n *\n * @example\n * // undefined => use common attributes\n * normalizeKeys(undefined, [{ id: 1, city: 'NYC' }], [{ city: 'NYC' }]);\n * // => { city: 'city' }\n *\n * @example\n * // Array of common attribute names\n * normalizeKeys(['city', 'country'], leftTuples, rightTuples);\n * // => { city: 'city', country: 'country' }\n *\n * @example\n * // Object mapping left attr to right attr\n * normalizeKeys({ city: 'location' }, leftTuples, rightTuples);\n * // => { city: 'location' }\n */\nexport const normalizeKeys = (keys: JoinKeys | undefined, leftTuples: Tuple[], rightTuples: Tuple[]): Record<AttrName, AttrName> => {\n  if (!keys) {\n    const common = getCommonAttrs(leftTuples, rightTuples);\n    return common.reduce((acc, attr) => {\n      acc[attr] = attr;\n      return acc;\n    }, {} as Record<AttrName, AttrName>);\n  }\n  if (Array.isArray(keys)) {\n    return keys.reduce((acc, attr) => {\n      acc[attr] = attr;\n      return acc;\n    }, {} as Record<AttrName, AttrName>);\n  }\n  return keys;\n}\n\n/**\n * Checks if two tuples match on the specified key mapping.\n *\n * @example\n * const keyMap = { city: 'location' };\n * tuplesMatch({ id: 1, city: 'NYC' }, { location: 'NYC', pop: 8 }, keyMap);\n * // => true (left.city === right.location)\n *\n * @example\n * const keyMap = { city: 'city' };\n * tuplesMatch({ city: 'NYC' }, { city: 'LA' }, keyMap);\n * // => false\n */\nexport const tuplesMatch = (left: Tuple, right: Tuple, keyMap: Record<AttrName, AttrName>): boolean => {\n  for (const [leftAttr, rightAttr] of Object.entries(keyMap)) {\n    if (left[leftAttr] !== right[rightAttr]) return false;\n  }\n  return true;\n}\n\n/**\n * Creates a string key from a tuple's join attributes for fast Set-based lookups.\n * Used by matching/not_matching for efficient semi-join operations.\n *\n * @example\n * const keyMap = { first: 'fname', last: 'lname' };\n *\n * // Left side uses left attr names (keys of keyMap)\n * matchKey({ id: 1, first: 'John', last: 'Doe' }, keyMap, 'left');\n * // => '\"John\"|\"Doe\"'\n *\n * // Right side uses right attr names (values of keyMap)\n * matchKey({ fname: 'John', lname: 'Doe', age: 30 }, keyMap, 'right');\n * // => '\"John\"|\"Doe\"'\n */\nexport const matchKey = (tuple: Tuple, keyMap: Record<AttrName, AttrName>, side: 'left' | 'right'): string => {\n  const attrs = side === 'left' ? Object.keys(keyMap) : Object.values(keyMap);\n  const values = attrs.map(attr => JSON.stringify(tuple[attr]));\n  return values.join('|');\n}\n\n/**\n * Removes join key attributes from a right tuple when merging.\n * Used to avoid duplicate columns in join results.\n *\n * @example\n * const keyMap = { city: 'location' };\n * projectOutKeys({ location: 'NYC', country: 'USA', pop: 8 }, keyMap);\n * // => { country: 'USA', pop: 8 }  (location removed)\n *\n * @example\n * const keyMap = { a: 'a', b: 'b' };\n * projectOutKeys({ a: 1, b: 2, c: 3 }, keyMap);\n * // => { c: 3 }  (a and b removed)\n */\nexport const projectOutKeys = (tuple: Tuple, keyMap: Record<AttrName, AttrName>): Tuple => {\n  const rightKeys = new Set(Object.values(keyMap));\n  const result: Tuple = {};\n  for (const [attr, value] of Object.entries(tuple)) {\n    if (!rightKeys.has(attr)) {\n      result[attr] = value;\n    }\n  }\n  return result;\n}\n","import { toPredicateFunc } from \"../support/toPredicateFunc\";\nimport { RelationOperand, Predicate, Tuple } from \"../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const restrict = (operand: RelationOperand, p: Predicate): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const f = toPredicateFunc(p)\n  const kept: Tuple[] = [];\n  for (const tuple of iterable) {\n    if (f(tuple)) kept.push(tuple);\n  }\n  return op.output(kept)\n}\n","import { toPredicateFunc } from \"../support/toPredicateFunc\";\nimport { RelationOperand, Predicate, Tuple } from \"../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const exclude = (operand: RelationOperand, p: Predicate): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const f = toPredicateFunc(p)\n  const kept: Tuple[] = [];\n  for (const tuple of iterable) {\n    if (!f(tuple)) kept.push(tuple);\n  }\n  return op.output(kept)\n}\n","import { RelationOperand, Tuple } from \"../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const constants = (operand: RelationOperand, consts: Tuple): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const result: Tuple[] = [];\n  for (const tuple of iterable) {\n    result.push({ ...tuple, ...consts });\n  }\n  return op.output(result)\n}\n","import { RelationOperand, Renaming, Tuple } from \"../types\";\nimport { toOperationalOperand, toRenamingFunc } from \"./_helpers\";\n\nexport const rename = (operand: RelationOperand, renaming: Renaming): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const renamingFunc = toRenamingFunc(renaming)\n  const result: Tuple[] = [];\n  for (const tuple of iterable) {\n    const renamed = Object.keys(tuple).reduce((memo, attr) => {\n      memo[renamingFunc(attr)] = tuple[attr];\n      return memo;\n    }, {})\n    result.push(renamed);\n  }\n  return op.output(result)\n}\n","import { PrefixOptions, RelationOperand } from \"../types\";\nimport { rename } from \"./rename\";\n\nexport const prefix = (operand: RelationOperand, pfx: string, options?: PrefixOptions): RelationOperand => {\n  const except = new Set(options?.except ?? []);\n  return rename(operand, (attr) => except.has(attr) ? attr : `${pfx}${attr}`);\n}\n","import { RelationOperand, SuffixOptions } from \"../types\";\nimport { rename } from \"./rename\";\n\nexport const suffix = (operand: RelationOperand, sfx: string, options?: SuffixOptions): RelationOperand => {\n  const except = new Set(options?.except ?? []);\n  return rename(operand, (attr) => except.has(attr) ? attr : `${attr}${sfx}`);\n}\n","import { RelationOperand, AttrName, Tuple } from \"../types\";\nimport { toOperationalOperand, deduplicate } from \"./_helpers\";\n\nexport const project = (operand: RelationOperand, attrs: AttrName[]): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const result: Tuple[] = [];\n  for (const tuple of iterable) {\n    const projected = attrs.reduce((memo, attr) => {\n      if (attr in tuple) {\n        memo[attr] = tuple[attr];\n      }\n      return memo;\n    }, {} as Tuple);\n    result.push(projected);\n  }\n  return op.output(deduplicate(result));\n}\n","import { RelationOperand, AttrName, Tuple } from \"../types\";\nimport { toOperationalOperand, deduplicate } from \"./_helpers\";\n\nexport const allbut = (operand: RelationOperand, attrs: AttrName[]): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const excluded = new Set(attrs);\n  const result: Tuple[] = [];\n  for (const tuple of iterable) {\n    const projected = Object.keys(tuple).reduce((memo, attr) => {\n      if (!excluded.has(attr)) {\n        memo[attr] = tuple[attr];\n      }\n      return memo;\n    }, {} as Tuple);\n    result.push(projected);\n  }\n  return op.output(deduplicate(result));\n}\n","import { RelationOperand, Extension, Tuple } from \"../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const extend = (operand: RelationOperand, extension: Extension): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const result: Tuple[] = [];\n  for (const tuple of iterable) {\n    const extended = { ...tuple };\n    for (const [attr, spec] of Object.entries(extension)) {\n      if (typeof spec === 'function') {\n        extended[attr] = spec(tuple);\n      } else {\n        extended[attr] = tuple[spec];\n      }\n    }\n    result.push(extended);\n  }\n  return op.output(result);\n}\n","import { RelationOperand, Tuple } from \"../types\";\nimport { toOperationalOperand, tupleKey } from \"./_helpers\";\n\nexport const union = (left: RelationOperand, right: RelationOperand): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n  const seen = new Set<string>();\n  const result: Tuple[] = [];\n\n  for (const tuple of opLeft.tuples()) {\n    const key = tupleKey(tuple);\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(tuple);\n    }\n  }\n\n  for (const tuple of opRight.tuples()) {\n    const key = tupleKey(tuple);\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(tuple);\n    }\n  }\n\n  return opLeft.output(result);\n}\n","import { RelationOperand, Tuple } from \"../types\";\nimport { toOperationalOperand, tupleKey } from \"./_helpers\";\n\nexport const minus = (left: RelationOperand, right: RelationOperand): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n\n  const rightKeys = new Set<string>();\n  for (const tuple of opRight.tuples()) {\n    rightKeys.add(tupleKey(tuple));\n  }\n\n  const seen = new Set<string>();\n  const result: Tuple[] = [];\n  for (const tuple of opLeft.tuples()) {\n    const key = tupleKey(tuple);\n    if (!rightKeys.has(key) && !seen.has(key)) {\n      seen.add(key);\n      result.push(tuple);\n    }\n  }\n\n  return opLeft.output(result);\n}\n","import { RelationOperand, Tuple } from \"../types\";\nimport { toOperationalOperand, tupleKey } from \"./_helpers\";\n\nexport const intersect = (left: RelationOperand, right: RelationOperand): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n\n  const rightKeys = new Set<string>();\n  for (const tuple of opRight.tuples()) {\n    rightKeys.add(tupleKey(tuple));\n  }\n\n  const seen = new Set<string>();\n  const result: Tuple[] = [];\n  for (const tuple of opLeft.tuples()) {\n    const key = tupleKey(tuple);\n    if (rightKeys.has(key) && !seen.has(key)) {\n      seen.add(key);\n      result.push(tuple);\n    }\n  }\n\n  return opLeft.output(result);\n}\n","import { RelationOperand, JoinKeys, Tuple } from \"../types\";\nimport { toOperationalOperand, normalizeKeys, matchKey } from \"./_helpers\";\n\nexport const matching = (left: RelationOperand, right: RelationOperand, keys?: JoinKeys): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n  const leftTuples = [...opLeft.tuples()];\n  const rightTuples = [...opRight.tuples()];\n  const keyMap = normalizeKeys(keys, leftTuples, rightTuples);\n\n  const rightKeys = new Set<string>();\n  for (const tuple of rightTuples) {\n    rightKeys.add(matchKey(tuple, keyMap, 'right'));\n  }\n\n  const result: Tuple[] = [];\n  for (const tuple of leftTuples) {\n    if (rightKeys.has(matchKey(tuple, keyMap, 'left'))) {\n      result.push(tuple);\n    }\n  }\n\n  return opLeft.output(result);\n}\n","import { RelationOperand, JoinKeys, Tuple } from \"../types\";\nimport { toOperationalOperand, normalizeKeys, matchKey } from \"./_helpers\";\n\nexport const not_matching = (left: RelationOperand, right: RelationOperand, keys?: JoinKeys): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n  const leftTuples = [...opLeft.tuples()];\n  const rightTuples = [...opRight.tuples()];\n  const keyMap = normalizeKeys(keys, leftTuples, rightTuples);\n\n  const rightKeys = new Set<string>();\n  for (const tuple of rightTuples) {\n    rightKeys.add(matchKey(tuple, keyMap, 'right'));\n  }\n\n  const result: Tuple[] = [];\n  for (const tuple of leftTuples) {\n    if (!rightKeys.has(matchKey(tuple, keyMap, 'left'))) {\n      result.push(tuple);\n    }\n  }\n\n  return opLeft.output(result);\n}\n","import { RelationOperand, JoinKeys, Tuple, AttrName } from \"../types\";\nimport { toOperationalOperand, normalizeKeys, tuplesMatch, projectOutKeys } from \"./_helpers\";\n\nconst mergeTuples = (left: Tuple, right: Tuple, keyMap: Record<AttrName, AttrName>): Tuple => {\n  return { ...left, ...projectOutKeys(right, keyMap) };\n}\n\nexport const join = (left: RelationOperand, right: RelationOperand, keys?: JoinKeys): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n  const leftTuples = [...opLeft.tuples()];\n  const rightTuples = [...opRight.tuples()];\n  const keyMap = normalizeKeys(keys, leftTuples, rightTuples);\n  const result: Tuple[] = [];\n\n  for (const leftTuple of leftTuples) {\n    for (const rightTuple of rightTuples) {\n      if (tuplesMatch(leftTuple, rightTuple, keyMap)) {\n        result.push(mergeTuples(leftTuple, rightTuple, keyMap));\n      }\n    }\n  }\n\n  return opLeft.output(result);\n}\n","import { RelationOperand, JoinKeys, Tuple, AttrName } from \"../types\";\nimport { toOperationalOperand, normalizeKeys, tuplesMatch } from \"./_helpers\";\n\nconst getRightAttrs = (rightTuples: Tuple[], keyMap: Record<AttrName, AttrName>): AttrName[] => {\n  if (rightTuples.length === 0) return [];\n  const rightKeys = new Set(Object.values(keyMap));\n  return Object.keys(rightTuples[0]).filter(attr => !rightKeys.has(attr));\n}\n\nconst mergeTuples = (left: Tuple, right: Tuple | null, rightAttrs: AttrName[]): Tuple => {\n  const result = { ...left };\n  for (const attr of rightAttrs) {\n    result[attr] = right ? right[attr] : null;\n  }\n  return result;\n}\n\nexport const left_join = (left: RelationOperand, right: RelationOperand, keys?: JoinKeys): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n  const leftTuples = [...opLeft.tuples()];\n  const rightTuples = [...opRight.tuples()];\n  const keyMap = normalizeKeys(keys, leftTuples, rightTuples);\n  const rightAttrs = getRightAttrs(rightTuples, keyMap);\n  const result: Tuple[] = [];\n\n  for (const leftTuple of leftTuples) {\n    let matched = false;\n    for (const rightTuple of rightTuples) {\n      if (tuplesMatch(leftTuple, rightTuple, keyMap)) {\n        result.push(mergeTuples(leftTuple, rightTuple, rightAttrs));\n        matched = true;\n      }\n    }\n    if (!matched) {\n      result.push(mergeTuples(leftTuple, null, rightAttrs));\n    }\n  }\n\n  return opLeft.output(result);\n}\n","import { RelationOperand, Tuple } from \"../types\";\nimport { toOperationalOperand, deduplicate } from \"./_helpers\";\n\nexport const cross_product = (left: RelationOperand, right: RelationOperand): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n  const leftTuples = [...opLeft.tuples()];\n  const rightTuples = [...opRight.tuples()];\n  const result: Tuple[] = [];\n\n  for (const l of leftTuples) {\n    for (const r of rightTuples) {\n      result.push({ ...r, ...l });\n    }\n  }\n\n  return opLeft.output(deduplicate(result));\n}\n\nexport { cross_product as cross_join };\n","import { RelationOperand, JoinKeys, Tuple, AttrName } from \"../types\";\nimport { toOperationalOperand, normalizeKeys, tuplesMatch, projectOutKeys } from \"./_helpers\";\nimport { MemoryRelation } from \"@/Relation\";\n\nexport const image = (left: RelationOperand, right: RelationOperand, as: AttrName, keys?: JoinKeys): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n  const leftTuples = [...opLeft.tuples()];\n  const rightTuples = [...opRight.tuples()];\n  const keyMap = normalizeKeys(keys, leftTuples, rightTuples);\n  const result: Tuple[] = [];\n\n  for (const leftTuple of leftTuples) {\n    const matches: Tuple[] = [];\n    for (const rightTuple of rightTuples) {\n      if (tuplesMatch(leftTuple, rightTuple, keyMap)) {\n        matches.push(projectOutKeys(rightTuple, keyMap));\n      }\n    }\n    result.push({\n      ...leftTuple,\n      [as]: new MemoryRelation(matches)\n    });\n  }\n\n  return opLeft.output(result);\n}\n","import { RelationOperand, AttrName, Tuple, Aggregator, Aggregators } from \"../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nconst groupKey = (tuple: Tuple, by: AttrName[]): string => {\n  const keyParts = by.map(attr => JSON.stringify(tuple[attr]));\n  return keyParts.join('|');\n}\n\nconst pickAttrs = (tuple: Tuple, attrs: AttrName[]): Tuple => {\n  return attrs.reduce((acc, attr) => {\n    acc[attr] = tuple[attr];\n    return acc;\n  }, {} as Tuple);\n}\n\nconst applyAggregator = (tuples: Tuple[], agg: Aggregator): unknown => {\n  if (typeof agg === 'function') {\n    return agg(tuples);\n  }\n\n  const spec = typeof agg === 'string' ? { op: agg, attr: '' } : agg;\n  const { op, attr } = spec;\n\n  switch (op) {\n    case 'count':\n      return tuples.length;\n\n    case 'sum': {\n      return tuples.reduce((sum, t) => sum + (Number(t[attr]) || 0), 0);\n    }\n\n    case 'min': {\n      const values = tuples.map(t => t[attr]).filter(v => v !== undefined && v !== null);\n      return values.length > 0 ? Math.min(...values.map(Number)) : null;\n    }\n\n    case 'max': {\n      const values = tuples.map(t => t[attr]).filter(v => v !== undefined && v !== null);\n      return values.length > 0 ? Math.max(...values.map(Number)) : null;\n    }\n\n    case 'avg': {\n      const values = tuples.map(t => Number(t[attr])).filter(v => !isNaN(v));\n      return values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : null;\n    }\n\n    case 'collect': {\n      return tuples.map(t => t[attr]);\n    }\n\n    default:\n      throw new Error(`Unknown aggregator: ${op}`);\n  }\n}\n\nexport const summarize = (\n  operand: RelationOperand,\n  by: AttrName[],\n  aggs: Aggregators\n): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const tuples = [...op.tuples()];\n\n  // Group tuples\n  const groups = new Map<string, Tuple[]>();\n  for (const tuple of tuples) {\n    const key = groupKey(tuple, by);\n    if (!groups.has(key)) {\n      groups.set(key, []);\n    }\n    groups.get(key)!.push(tuple);\n  }\n\n  // Apply aggregators to each group\n  const result: Tuple[] = [];\n  for (const groupTuples of groups.values()) {\n    const row: Tuple = pickAttrs(groupTuples[0], by);\n    for (const [resultAttr, agg] of Object.entries(aggs)) {\n      row[resultAttr] = applyAggregator(groupTuples, agg);\n    }\n    result.push(row);\n  }\n\n  return op.output(result);\n}\n","import { RelationOperand, AttrName, Tuple } from \"../types\";\nimport { toOperationalOperand } from \"./_helpers\";\nimport { MemoryRelation } from \"@/Relation\";\n\nconst groupKey = (tuple: Tuple, byAttrs: AttrName[]): string => {\n  const keyParts = byAttrs.map(attr => JSON.stringify(tuple[attr]));\n  return keyParts.join('|');\n}\n\nconst pickAttrs = (tuple: Tuple, attrs: AttrName[]): Tuple => {\n  return attrs.reduce((acc, attr) => {\n    acc[attr] = tuple[attr];\n    return acc;\n  }, {} as Tuple);\n}\n\nexport const group = (operand: RelationOperand, attrs: AttrName[], as: AttrName): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const tuples = [...op.tuples()];\n\n  if (tuples.length === 0) {\n    return op.output([]);\n  }\n\n  // Determine which attributes to keep at the top level (all except grouped ones)\n  const allAttrs = Object.keys(tuples[0]);\n  const groupedSet = new Set(attrs);\n  const byAttrs = allAttrs.filter(a => !groupedSet.has(a));\n\n  // Group tuples\n  const groups = new Map<string, { base: Tuple, nested: Tuple[] }>();\n  for (const tuple of tuples) {\n    const key = groupKey(tuple, byAttrs);\n    if (!groups.has(key)) {\n      groups.set(key, {\n        base: pickAttrs(tuple, byAttrs),\n        nested: []\n      });\n    }\n    groups.get(key)!.nested.push(pickAttrs(tuple, attrs));\n  }\n\n  // Build result with nested relations\n  const result: Tuple[] = [];\n  for (const { base, nested } of groups.values()) {\n    result.push({\n      ...base,\n      [as]: new MemoryRelation(nested)\n    });\n  }\n\n  return op.output(result);\n}\n","import { RelationOperand, AttrName, Tuple, Relation } from \"../types\";\nimport { toOperationalOperand } from \"./_helpers\";\nimport { isRelation } from \"./isRelation\";\n\nconst toTupleArray = (value: unknown): Tuple[] => {\n  if (isRelation(value)) {\n    return (value as Relation).toArray();\n  }\n  if (Array.isArray(value)) {\n    return value;\n  }\n  throw new Error(`Value is not a relation or array`);\n}\n\nexport const ungroup = (operand: RelationOperand, attr: AttrName): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const tuples = [...op.tuples()];\n  const result: Tuple[] = [];\n\n  for (const tuple of tuples) {\n    const nested = toTupleArray(tuple[attr]);\n\n    // Get base attributes (all except the grouped one)\n    const base: Tuple = {};\n    for (const [key, value] of Object.entries(tuple)) {\n      if (key !== attr) {\n        base[key] = value;\n      }\n    }\n\n    // Flatten each nested tuple\n    for (const nestedTuple of nested) {\n      result.push({\n        ...base,\n        ...nestedTuple\n      });\n    }\n  }\n\n  return op.output(result);\n}\n","import { RelationOperand, AttrName, Tuple } from \"../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const wrap = (operand: RelationOperand, attrs: AttrName[], as: AttrName): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const wrappedSet = new Set(attrs);\n  const result: Tuple[] = [];\n\n  for (const tuple of iterable) {\n    const wrapped: Tuple = {};\n    const remaining: Tuple = {};\n\n    for (const [key, value] of Object.entries(tuple)) {\n      if (wrappedSet.has(key)) {\n        wrapped[key] = value;\n      } else {\n        remaining[key] = value;\n      }\n    }\n\n    result.push({\n      ...remaining,\n      [as]: wrapped\n    });\n  }\n\n  return op.output(result);\n}\n","import { RelationOperand, AttrName, Tuple } from \"../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const unwrap = (operand: RelationOperand, attr: AttrName): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const result: Tuple[] = [];\n\n  for (const tuple of iterable) {\n    const wrapped = tuple[attr] as Tuple;\n    if (typeof wrapped !== 'object' || wrapped === null || Array.isArray(wrapped)) {\n      throw new Error(`Attribute '${attr}' is not a tuple (object)`);\n    }\n\n    const unwrapped: Tuple = {};\n    for (const [key, value] of Object.entries(tuple)) {\n      if (key !== attr) {\n        unwrapped[key] = value;\n      }\n    }\n\n    result.push({\n      ...unwrapped,\n      ...wrapped\n    });\n  }\n\n  return op.output(result);\n}\n","import { AutowrapOptions, RelationOperand, Tuple } from \"../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const autowrap = (operand: RelationOperand, options?: AutowrapOptions): RelationOperand => {\n  const sep = options?.separator ?? '_';\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const result: Tuple[] = [];\n\n  for (const tuple of iterable) {\n    const wrapped: Tuple = {};\n    for (const [attr, value] of Object.entries(tuple)) {\n      const parts = attr.split(sep);\n      if (parts.length === 1) {\n        wrapped[attr] = value;\n      } else {\n        const [prefix, ...rest] = parts;\n        wrapped[prefix] = wrapped[prefix] ?? {};\n        (wrapped[prefix] as Tuple)[rest.join(sep)] = value;\n      }\n    }\n    result.push(wrapped);\n  }\n\n  return op.output(result);\n}\n","import { RelationOperand, Transformation, Tuple } from \"../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const transform = (operand: RelationOperand, transformation: Transformation): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const result: Tuple[] = [];\n\n  for (const tuple of iterable) {\n    const transformed: Tuple = {};\n\n    for (const [attr, value] of Object.entries(tuple)) {\n      transformed[attr] = applyTransformation(value, attr, transformation);\n    }\n\n    result.push(transformed);\n  }\n\n  return op.output(result);\n}\n\nconst applyTransformation = (value: unknown, attr: string, transformation: Transformation): unknown => {\n  if (typeof transformation === 'function') {\n    // Single function - apply to all values\n    return transformation(value);\n  } else if (Array.isArray(transformation)) {\n    // Array of functions - chain them\n    return transformation.reduce((v, fn) => fn(v), value);\n  } else {\n    // Object with attr-specific transformers\n    const fn = transformation[attr];\n    if (fn) {\n      if (Array.isArray(fn)) {\n        return fn.reduce((v, f) => f(v), value);\n      }\n      return fn(value);\n    }\n    return value;\n  }\n}\n","import { RelationOperand } from \"../types\";\nimport { toOperationalOperand, tupleKey } from \"./_helpers\";\n\nexport const isEqual = (left: RelationOperand, right: RelationOperand): boolean => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n\n  const leftKeys = new Set<string>();\n  for (const tuple of opLeft.tuples()) {\n    leftKeys.add(tupleKey(tuple));\n  }\n\n  const rightKeys = new Set<string>();\n  for (const tuple of opRight.tuples()) {\n    rightKeys.add(tupleKey(tuple));\n  }\n\n  if (leftKeys.size !== rightKeys.size) {\n    return false;\n  }\n\n  for (const key of leftKeys) {\n    if (!rightKeys.has(key)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","import { RelationOperand, Tuple } from \"../types\";\nimport { toOperationalOperand, error } from \"./_helpers\";\n\nexport const one = (operand: RelationOperand): Tuple => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  let tuple;\n  for (const t of iterable) {\n    if (tuple) {\n      return error('More than one tuple found');\n    } else {\n      tuple = t;\n    }\n  }\n  if (tuple) return tuple;\n  return error('Relation is empty');\n}\n","import { AttrName, RelationOperand, Tuple } from \"../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const yByX = (operand: RelationOperand, y: AttrName, x: AttrName): Tuple => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const hash = {};\n  for (const tuple of iterable) {\n    hash[`${tuple[x]}`] = tuple[y];\n  }\n  return hash;\n}\n","export * from './operators';\nexport * from './types';\nexport { LIB_DEFINITIONS } from './lib-definitions';\n\nimport { MemoryRelation } from './Relation';\nimport { isRelation } from './operators';\n\n/**\n * Creates a new in-memory relation from an array of tuples.\n *\n * @typeParam T - The tuple type. Inferred from input or explicitly provided.\n *\n * @example\n * // Untyped usage (backwards compatible)\n * const r = Bmg([{ id: 1, name: 'Alice' }]);\n *\n * @example\n * // Typed usage with explicit type parameter\n * interface Person { id: number; name: string }\n * const r = Bmg<Person>([{ id: 1, name: 'Alice' }]);\n * r.project(['id']);  // Autocomplete suggests 'id' | 'name'\n *\n * @example\n * // Type is inferred from input\n * const r = Bmg([{ id: 1, name: 'Alice' }] as const);\n */\nexport function Bmg<T>(tuples: T[]): MemoryRelation<T> {\n  return new MemoryRelation<T>(tuples);\n}\n\nBmg.isRelation = isRelation;\n","// Auto-generated from types.ts\n// Run 'npm run generate:lib-definitions' to regenerate\n\nexport const LIB_DEFINITIONS = `\n/**\n * Type definitions for Bmg.js relational algebra library.\n *\n * This file defines all types needed for type-safe relational operations:\n * - Base types (AttrName, Tuple)\n * - Utility types for transformations (Renamed, Prefixed, Joined, etc.)\n * - The Relation interface with all operators\n * - Helper types for predicates, extensions, aggregators, etc.\n */\n\n// ============================================================================\n// Base Types\n// ============================================================================\n\n/** Attribute name in a tuple */\ntype AttrName = string\n\n/** A tuple is a record mapping attribute names to values */\ntype Tuple = Record<AttrName, unknown>\n\n// ============================================================================\n// Rename Types\n// ============================================================================\n\n/** Map from old attribute names to new attribute names */\ntype RenameMap<T> = { [K in keyof T]?: string };\n\n/** Transform tuple type by renaming keys according to RenameMap */\ntype Renamed<T, R extends RenameMap<T>> = {\n  [K in keyof T as K extends keyof R ? (R[K] extends string ? R[K] : K) : K]: T[K];\n};\n\n// ============================================================================\n// Prefix/Suffix Types\n// ============================================================================\n\n/** Prefix all keys except those in Except */\ntype Prefixed<T, P extends string, Except extends keyof T = never> = {\n  [K in keyof T as K extends Except ? K : \\`\\${P}\\${K & string}\\`]: T[K];\n};\n\n/** Suffix all keys except those in Except */\ntype Suffixed<T, S extends string, Except extends keyof T = never> = {\n  [K in keyof T as K extends Except ? K : \\`\\${K & string}\\${S}\\`]: T[K];\n};\n\n// ============================================================================\n// Join Types\n// ============================================================================\n\n/** Extract common keys between two tuple types */\ntype CommonKeys<L, R> = Extract<keyof L, keyof R>;\n\n/** Result of inner join: L & R with R's common keys removed */\ntype Joined<L, R> = L & Omit<R, CommonKeys<L, R>>;\n\n/** Result of left join: L & optional R attributes (common keys removed) */\ntype LeftJoined<L, R> = L & Partial<Omit<R, CommonKeys<L, R>>>;\n\n/**\n * Typed join keys for array form: keys must exist on BOTH operands.\n * Example: suppliers.join(parts, ['city']) - 'city' must be a key of both.\n */\ntype TypedJoinKeysArray<L, R> = (keyof L & keyof R & string)[];\n\n/**\n * Typed join keys for object form: maps left keys to right keys.\n * Example: suppliers.join(parts, { sid: 'supplier_id' })\n * - Left key (sid) must exist on L\n * - Right key (supplier_id) must exist on R\n */\ntype TypedJoinKeysObject<L, R> = { [K in keyof L & string]?: keyof R & string };\n\n// ============================================================================\n// Wrap/Unwrap Types\n// ============================================================================\n\n/** Result of wrap: remove wrapped attrs, add nested object */\ntype Wrapped<T, K extends keyof T, As extends string> =\n  Omit<T, K> & Record<As, Pick<T, K>>;\n\n/** Result of unwrap: remove object attr, spread its properties */\ntype Unwrapped<T, K extends keyof T> =\n  T[K] extends Record<string, unknown> ? Omit<T, K> & T[K] : Omit<T, K>;\n\n/** Result of ungroup: remove relation attr, flatten its tuple type */\ntype Ungrouped<T, K extends keyof T> =\n  T[K] extends Relation<infer N> ? Omit<T, K> & N : Omit<T, K>;\n\n// ============================================================================\n// Aggregator Types\n// ============================================================================\n\ntype AggregatorName = 'count' | 'sum' | 'min' | 'max' | 'avg' | 'collect'\ntype AggregatorSpec = { op: AggregatorName, attr: AttrName }\ntype AggregatorFunc = (tuples: Tuple[]) => unknown\ntype Aggregator = AggregatorName | AggregatorSpec | AggregatorFunc\ntype Aggregators = Record<AttrName, Aggregator>\n\n/** Infer result type from aggregator specification */\ntype AggregatorResult<A> =\n  A extends 'count' ? number :\n  A extends { op: 'count' } ? number :\n  A extends { op: 'sum' | 'avg' | 'min' | 'max' } ? number | null :\n  A extends { op: 'collect' } ? unknown[] :\n  A extends (tuples: Tuple[]) => infer R ? R :\n  unknown;\n\n/** Map aggregator definitions to their result types */\ntype AggregatorResults<Aggs extends Record<string, unknown>> = {\n  [K in keyof Aggs]: AggregatorResult<Aggs[K]>;\n};\n\n// ============================================================================\n// Predicate Types\n// ============================================================================\n\n/** Predicate function that receives a typed tuple */\ntype TypedPredicateFunc<T> = (t: T) => boolean\n\n/** Predicate: either a partial tuple for equality matching, or a function */\ntype TypedPredicate<T> = Partial<T> | TypedPredicateFunc<T>\n\n// Legacy predicate types (for backwards compatibility with standalone operators)\ntype PredicateFunc = ((t: Tuple) => any)\ntype Predicate = Tuple | PredicateFunc\n\n// ============================================================================\n// Extension Types\n// ============================================================================\n\n/** Extension function that receives a typed tuple */\ntype TypedExtensionFunc<T, R> = (tuple: T) => R\n\n/** Extension definition: function returning value, or attribute name to copy */\ntype TypedExtension<T, E extends Record<string, unknown>> = {\n  [K in keyof E]: TypedExtensionFunc<T, E[K]> | keyof T;\n}\n\ntype ExtensionFunc = (tuple: Tuple) => unknown\ntype Extension = Record<AttrName, ExtensionFunc | AttrName>\n\n// ============================================================================\n// Other Helper Types\n// ============================================================================\n\ninterface PrefixOptions {\n  except?: AttrName[]\n}\n\ninterface SuffixOptions {\n  except?: AttrName[]\n}\n\ninterface AutowrapOptions {\n  separator?: string\n}\n\ntype Renaming = RenamingObj | RenamingFunc\ntype RenamingFunc = (attr: AttrName) => AttrName\ntype RenamingObj = Record<AttrName, AttrName>\n\ntype JoinKeys = AttrName[] | Record<AttrName, AttrName>\n\ntype TransformFunc = (value: unknown) => unknown\ntype Transformation = TransformFunc | TransformFunc[] | Record<AttrName, TransformFunc | TransformFunc[]>\n\n// ============================================================================\n// Relation Interface\n// ============================================================================\n\n/**\n * Relation interface with generic type parameter for tuple type.\n * Default parameter \\`Tuple\\` ensures backwards compatibility.\n *\n * @typeParam T - The tuple type for this relation. Defaults to \\`Tuple\\` (Record<string, unknown>).\n *\n * @example\n * // Untyped usage (backwards compatible)\n * const r = Bmg([{ id: 1 }]);  // Relation<Tuple>\n *\n * @example\n * // Typed usage with full type safety\n * interface Person { id: number; name: string }\n * const r = Bmg<Person>([{ id: 1, name: 'Alice' }]);\n * r.project(['id']);  // Relation<{ id: number }>\n */\ninterface Relation<T = Tuple> {\n  // === Type-preserving operators ===\n\n  restrict(p: TypedPredicate<T>): Relation<T>\n  where(p: TypedPredicate<T>): Relation<T>\n  exclude(p: TypedPredicate<T>): Relation<T>\n\n  // === Projection operators ===\n\n  project<K extends keyof T>(attrs: K[]): Relation<Pick<T, K>>\n  allbut<K extends keyof T>(attrs: K[]): Relation<Omit<T, K>>\n\n  // === Extension operators ===\n\n  extend<E extends Record<string, unknown>>(e: TypedExtension<T, E>): Relation<T & E>\n  constants<C extends Tuple>(consts: C): Relation<T & C>\n\n  // === Rename operators ===\n\n  rename<R extends RenameMap<T>>(r: R): Relation<Renamed<T, R>>\n  prefix<P extends string, Ex extends keyof T = never>(pfx: P, options?: { except?: Ex[] }): Relation<Prefixed<T, P, Ex>>\n  suffix<S extends string, Ex extends keyof T = never>(sfx: S, options?: { except?: Ex[] }): Relation<Suffixed<T, S, Ex>>\n\n  // === Set operators (require same type) ===\n\n  union(right: RelationOperand<T>): Relation<T>\n  minus(right: RelationOperand<T>): Relation<T>\n  intersect(right: RelationOperand<T>): Relation<T>\n\n  // === Semi-join operators (preserve left type) ===\n\n  matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T>\n  not_matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T>\n\n  // === Join operators ===\n\n  join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<Joined<T, R>>\n  left_join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<LeftJoined<T, R>>\n  cross_product<R>(right: RelationOperand<R>): Relation<T & R>\n  cross_join<R>(right: RelationOperand<R>): Relation<T & R>\n\n  // === Nesting operators ===\n\n  image<R, As extends string>(right: RelationOperand<R>, as: As, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T & Record<As, Relation<Omit<R, keyof T & keyof R>>>>\n  group<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Omit<T, K> & Record<As, Relation<Pick<T, K>>>>\n  ungroup<K extends keyof T>(attr: K): Relation<Ungrouped<T, K>>\n  wrap<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Wrapped<T, K, As>>\n  unwrap<K extends keyof T>(attr: K): Relation<Unwrapped<T, K>>\n\n  // === Aggregation ===\n\n  summarize<By extends keyof T, Aggs extends Aggregators>(by: By[], aggs: Aggs): Relation<Pick<T, By> & AggregatorResults<Aggs>>\n\n  // === Transform ===\n\n  transform(t: Transformation): Relation<T>\n\n  // === Dynamic (loses type precision) ===\n\n  autowrap(options?: AutowrapOptions): Relation<Tuple>\n\n  // === Non-relational ===\n\n  one(): T\n  yByX<Y extends keyof T, X extends keyof T>(y: Y, x: X): Record<T[X] & PropertyKey, T[Y]>\n  toArray(): T[]\n  isEqual(right: any): boolean\n}\n\n// ============================================================================\n// Operands\n// ============================================================================\n\ntype RelationOperand<T = Tuple> = Relation<T> | T[]\n\ninterface OperationalOperand<T = Tuple> {\n  tuples(): Iterable<T>\n  output(tuples: T[]): RelationOperand<T>\n}\n\n// ============================================================================\n// Bmg Function Declaration\n// ============================================================================\n\n/** Create a relation from an array of tuples */\ndeclare function Bmg<T>(tuples: T[]): Relation<T>\ndeclare namespace Bmg {\n  function isRelation(op: unknown): boolean\n}\n`\n"],"names":["toPredicateFunc","p","expected","t","Object","keys","every","k","MemoryRelation","tuples","this","_proto","prototype","restrict","where","exclude","project","attrs","allbut","extend","e","constants","consts","rename","r","prefix","pfx","options","suffix","sfx","union","right","minus","intersect","matching","not_matching","join","left_join","cross_product","cross_join","image","as","group","ungroup","attr","wrap","unwrap","summarize","by","aggs","transform","autowrap","one","toArray","yByX","y","x","isEqual","isRelation","op","constructor","tupleKey","tuple","entries","map","_ref","v","value","sort","JSON","stringify","_ref2","_ref3","localeCompare","deduplicate","_step","seen","Set","result","_iterator","_createForOfIteratorHelperLoose","done","key","has","add","push","toOperationalOperand","operand","Array","isArray","output","error","msg","normalizeKeys","leftTuples","rightTuples","reduce","acc","left","length","leftAttrs","filter","getCommonAttrs","tuplesMatch","keyMap","_i","_Object$entries","_Object$entries$_i","matchKey","side","values","projectOutKeys","rightKeys","_i2","_Object$entries2","_Object$entries2$_i","iterable","f","kept","_extends","renaming","renamingFunc","toRenamingFunc","_loop","renamed","memo","_options$except","except","projected","excluded","extension","extended","spec","opLeft","opRight","_step2","_iterator2","concat","mergeTuples","leftTuple","rightTuple","rightAttrs","getRightAttrs","_step3","matched","_iterator3","l","_extends2","matches","groupKey","pickAttrs","applyAggregator","agg","sum","Number","Math","min","apply","max","isNaN","a","b","Error","groups","Map","set","get","groupTuples","row","byAttrs","allAttrs","groupedSet","base","nested","_step2$value","toTupleArray","wrappedSet","wrapped","remaining","unwrapped","_options$separator","sep","separator","parts","split","_wrapped$prefix","rest","_arrayLikeToArray","slice","transformation","transformed","applyTransformation","fn","leftKeys","size","hash","Bmg"],"mappings":"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"}
+{"version":3,"file":"bmg.cjs","sources":["../src/support/toPredicateFunc.ts","../src/sync/operators/isRelation.ts","../src/writer/Text.ts","../src/sync/Relation/Memory.ts","../src/sync/operators/_helpers.ts","../src/sync/operators/restrict.ts","../src/sync/operators/exclude.ts","../src/sync/operators/constants.ts","../src/sync/operators/rename.ts","../src/sync/operators/prefix.ts","../src/sync/operators/suffix.ts","../src/sync/operators/project.ts","../src/sync/operators/allbut.ts","../src/sync/operators/extend.ts","../src/sync/operators/union.ts","../src/sync/operators/minus.ts","../src/sync/operators/intersect.ts","../src/sync/operators/matching.ts","../src/sync/operators/not_matching.ts","../src/sync/operators/join.ts","../src/sync/operators/left_join.ts","../src/sync/operators/cross_product.ts","../src/sync/operators/image.ts","../src/sync/operators/summarize.ts","../src/sync/operators/group.ts","../src/sync/operators/ungroup.ts","../src/sync/operators/wrap.ts","../src/sync/operators/unwrap.ts","../src/sync/operators/autowrap.ts","../src/sync/operators/transform.ts","../src/sync/operators/isEqual.ts","../src/sync/operators/one.ts","../src/sync/operators/yByX.ts","../src/index.ts","../src/lib-definitions.ts"],"sourcesContent":["import { Predicate, PredicateFunc, Tuple } from '../types';\n\nexport const toPredicateFunc = (p: Predicate): PredicateFunc => {\n  if (typeof(p) === 'function') {\n    return p as PredicateFunc;\n  } else {\n    const expected = p as Tuple;\n    return (t: Tuple) => {\n      return Object.keys(expected).every(k => t[k] === expected[k])\n    }\n  }\n}\n","import { MemoryRelation } from \"@/sync/Relation\";\nimport { Relation } from \"@/types\";\n\nexport const isRelation = (op: unknown): op is Relation => {\n  return op != null && (op as object).constructor === MemoryRelation;\n}\n","import { Relation, Tuple } from '../types';\nimport { isRelation } from '../sync/operators/isRelation';\n\n/**\n * Options for text rendering\n */\nexport interface TextOptions {\n  /** Format string for floating point numbers (default: '%.3f' style) */\n  floatPrecision?: number;\n  /** Maximum width to trim output at */\n  trimAt?: number;\n}\n\n// Type guards\nconst isTupleLike = (t: unknown): t is Tuple =>\n  t !== null && typeof t === 'object' && !Array.isArray(t);\n\nconst isRelationLike = (r: unknown): r is Relation | Tuple[] =>\n  isRelation(r) || (Array.isArray(r) && r.every(isTupleLike));\n\n/**\n * Utility function to get max of two nullable numbers\n */\nconst max = (x: number | null, y: number | null): number => {\n  if (x === null) return y ?? 0;\n  if (y === null) return x;\n  return x > y ? x : y;\n};\n\n/**\n * Represents a single cell in the table\n */\nclass Cell {\n  private value: unknown;\n  private renderer: TextWriter;\n  private _textRendering: string | null = null;\n  private _minWidth: number | null = null;\n\n  constructor(renderer: TextWriter, value: unknown) {\n    this.renderer = renderer;\n    this.value = value;\n  }\n\n  get minWidth(): number {\n    if (this._minWidth === null) {\n      this._minWidth = this.renderingLines().reduce(\n        (maxLen, line) => max(maxLen, line.length),\n        0\n      );\n    }\n    return this._minWidth;\n  }\n\n  renderingLines(size?: number): string[] {\n    if (size === undefined) {\n      return this.textRendering.split('\\n');\n    } else if (typeof this.value === 'number') {\n      // Right-align numbers\n      return this.renderingLines().map(l => l.padStart(size));\n    } else {\n      // Left-align other values\n      return this.renderingLines().map(l => l.padEnd(size));\n    }\n  }\n\n  get textRendering(): string {\n    if (this._textRendering === null) {\n      this._textRendering = this.computeTextRendering();\n    }\n    return this._textRendering;\n  }\n\n  private computeTextRendering(): string {\n    const value = this.value;\n\n    if (value === null) {\n      return '[null]';\n    }\n    if (value === undefined) {\n      return '[undefined]';\n    }\n    if (typeof value === 'symbol') {\n      return value.toString();\n    }\n    if (typeof value === 'number') {\n      if (Number.isInteger(value)) {\n        return String(value);\n      }\n      const precision = this.renderer.options.floatPrecision ?? 3;\n      return value.toFixed(precision);\n    }\n    if (isRelationLike(value)) {\n      return this.renderer.render(value, '');\n    }\n    if (Array.isArray(value)) {\n      return this.arrayRendering(value);\n    }\n    if (value instanceof Date) {\n      return value.toISOString();\n    }\n    if (typeof value === 'object') {\n      return JSON.stringify(value);\n    }\n    return String(value);\n  }\n\n  private arrayRendering(value: unknown[]): string {\n    if (value.length > 0 && isTupleLike(value[0])) {\n      return this.renderer.render(value as Tuple[], '');\n    }\n    if (value.length === 0) {\n      return '[]';\n    }\n    const values = value.map(x => {\n      const cell = new Cell(this.renderer, x);\n      return cell.textRendering;\n    });\n    const totalLength = values.reduce((sum, s) => sum + s.length, 0);\n    if (totalLength < 20) {\n      return '[' + values.join(', ') + ']';\n    } else {\n      return '[' + values.join(',\\n ') + ']';\n    }\n  }\n}\n\n/**\n * Represents a row of cells in the table\n */\nclass Row {\n  private cells: Cell[];\n\n  constructor(renderer: TextWriter, values: unknown[]) {\n    this.cells = values.map(v => new Cell(renderer, v));\n  }\n\n  minWidths(): number[] {\n    return this.cells.map(cell => cell.minWidth);\n  }\n\n  renderingLines(sizes: number[]): string[] {\n    let nbLines = 0;\n    const byCell = this.cells.map((cell, i) => {\n      const lines = cell.renderingLines(sizes[i]);\n      nbLines = max(nbLines, lines.length);\n      return lines;\n    });\n\n    const grid: string[] = [];\n    for (let lineI = 0; lineI < nbLines; lineI++) {\n      const lineContent = byCell\n        .map((cellLines, i) => cellLines[lineI] ?? ' '.repeat(sizes[i]))\n        .join(' | ');\n      grid.push('| ' + lineContent + ' |');\n    }\n\n    return grid.length === 0 ? ['|  |'] : grid;\n  }\n}\n\n/**\n * Represents the entire table structure\n */\nclass Table {\n  private renderer: TextWriter;\n  private header: Row;\n  private rows: Row[];\n  private _sizes: number[] | null = null;\n  private _sep: string | null = null;\n\n  constructor(renderer: TextWriter, records: unknown[][], attributes: string[]) {\n    this.renderer = renderer;\n    this.header = new Row(renderer, attributes);\n    this.rows = records.map(r => new Row(renderer, r));\n  }\n\n  get sizes(): number[] {\n    if (this._sizes === null) {\n      const headerWidths = this.header.minWidths();\n      this._sizes = this.rows.reduce((memo, row) => {\n        const rowWidths = row.minWidths();\n        return memo.map((w, i) => max(w, rowWidths[i] ?? 0));\n      }, headerWidths);\n    }\n    return this._sizes;\n  }\n\n  get sep(): string {\n    if (this._sep === null) {\n      this._sep = '+-' + this.sizes.map(s => '-'.repeat(s)).join('-+-') + '-+';\n    }\n    return this._sep;\n  }\n\n  *eachLine(): Generator<string> {\n    const trimAt = this.renderer.options.trimAt;\n\n    if (trimAt !== undefined) {\n      for (const line of this.eachLineRaw()) {\n        yield line.substring(0, trimAt);\n      }\n    } else {\n      yield* this.eachLineRaw();\n    }\n  }\n\n  private *eachLineRaw(): Generator<string> {\n    yield this.sep;\n    yield this.header.renderingLines(this.sizes)[0];\n    yield this.sep;\n    for (const row of this.rows) {\n      for (const line of row.renderingLines(this.sizes)) {\n        yield line;\n      }\n    }\n    yield this.sep;\n  }\n\n  *[Symbol.iterator](): Generator<string> {\n    for (const line of this.eachLine()) {\n      yield line.trimEnd() + '\\n';\n    }\n  }\n\n  toString(): string {\n    let result = '';\n    for (const line of this) {\n      result += line;\n    }\n    return result;\n  }\n}\n\n/**\n * Text writer for rendering relations as ASCII tables\n */\nexport class TextWriter {\n  readonly options: TextOptions;\n\n  constructor(options: TextOptions = {}) {\n    this.options = options;\n  }\n\n  /**\n   * Renders a relation or tuple array to an ASCII table string\n   */\n  render(input: Relation | Tuple[] | Tuple, output: string = ''): string {\n    for (const line of this.eachLine(input)) {\n      output += line;\n    }\n    return output;\n  }\n\n  *eachLine(input: Relation | Tuple[] | Tuple): Generator<string> {\n    // Handle single tuple\n    let tuples: Tuple[];\n    if (isTupleLike(input) && !isRelation(input)) {\n      tuples = [input];\n    } else if (isRelation(input)) {\n      tuples = input.toArray();\n    } else {\n      tuples = input;\n    }\n\n    // Collect all attribute names across all tuples\n    const attrs = tuples.reduce((memo: string[], tuple) => {\n      for (const key of Object.keys(tuple)) {\n        if (!memo.includes(key)) {\n          memo.push(key);\n        }\n      }\n      return memo;\n    }, []);\n\n    // Build records array (values in attribute order)\n    const records = tuples.map(t => attrs.map(a => t[a]));\n\n    const table = new Table(this, records, attrs);\n    yield* table;\n  }\n}\n\n/**\n * Renders a relation as an ASCII table string\n *\n * @param operand - The relation or tuple array to render\n * @param options - Text rendering options\n * @returns ASCII table string representation\n *\n * @example\n * const r = Bmg([{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]);\n * console.log(toText(r));\n * // +----+-------+\n * // | id | name  |\n * // +----+-------+\n * // |  1 | Alice |\n * // |  2 | Bob   |\n * // +----+-------+\n */\nexport const toText = (\n  operand: Relation | Tuple[] | Tuple,\n  options: TextOptions = {}\n): string => {\n  return new TextWriter(options).render(operand);\n};\n","import {\n  allbut,\n  autowrap,\n  constants,\n  cross_product,\n  exclude,\n  extend,\n  group,\n  image,\n  intersect,\n  isEqual,\n  join,\n  left_join,\n  matching,\n  minus,\n  not_matching,\n  one,\n  prefix,\n  project,\n  rename,\n  restrict,\n  suffix,\n  summarize,\n  where,\n  transform,\n  ungroup,\n  union,\n  unwrap,\n  wrap,\n  yByX,\n} from \"../operators\";\nimport type {\n  AttrName,\n  AutowrapOptions,\n  Relation,\n  RelationOperand,\n  TextOptions,\n  Transformation,\n  Tuple,\n  TypedPredicate,\n  TypedExtension,\n  RenameMap,\n  Renamed,\n  Prefixed,\n  Suffixed,\n  Joined,\n  LeftJoined,\n  Wrapped,\n  Unwrapped,\n  Ungrouped,\n  AggregatorResults,\n  TypedJoinKeysArray,\n  TypedJoinKeysObject,\n} from \"../../types\";\nimport { toText } from \"../../writer\";\n\n/**\n * In-memory implementation of the Relation interface.\n *\n * @typeParam T - The tuple type for this relation. Defaults to `Tuple` (Record<string, unknown>).\n */\nexport class MemoryRelation<T = Tuple> implements Relation<T> {\n\n  constructor(private tuples: T[]) {\n    this.tuples = tuples;\n  }\n\n  // === Type-preserving operators ===\n\n  restrict(p: TypedPredicate<T>): Relation<T> {\n    return restrict(this as any, p as any) as unknown as Relation<T>;\n  }\n\n  where(p: TypedPredicate<T>): Relation<T> {\n    return where(this as any, p as any) as unknown as Relation<T>;\n  }\n\n  exclude(p: TypedPredicate<T>): Relation<T> {\n    return exclude(this as any, p as any) as unknown as Relation<T>;\n  }\n\n  // === Projection operators ===\n\n  project<K extends keyof T>(attrs: K[]): Relation<Pick<T, K>> {\n    return project(this as any, attrs as AttrName[]) as unknown as Relation<Pick<T, K>>;\n  }\n\n  allbut<K extends keyof T>(attrs: K[]): Relation<Omit<T, K>> {\n    return allbut(this as any, attrs as AttrName[]) as unknown as Relation<Omit<T, K>>;\n  }\n\n  // === Extension operators ===\n\n  extend<E extends Record<string, unknown>>(e: TypedExtension<T, E>): Relation<T & E> {\n    return extend(this as any, e as any) as unknown as Relation<T & E>;\n  }\n\n  constants<C extends Tuple>(consts: C): Relation<T & C> {\n    return constants(this as any, consts) as unknown as Relation<T & C>;\n  }\n\n  // === Rename operators ===\n\n  rename<R extends RenameMap<T>>(r: R): Relation<Renamed<T, R>> {\n    return rename(this as any, r as any) as unknown as Relation<Renamed<T, R>>;\n  }\n\n  prefix<P extends string, Ex extends keyof T = never>(pfx: P, options?: { except?: Ex[] }): Relation<Prefixed<T, P, Ex>> {\n    return prefix(this as any, pfx, options as any) as unknown as Relation<Prefixed<T, P, Ex>>;\n  }\n\n  suffix<S extends string, Ex extends keyof T = never>(sfx: S, options?: { except?: Ex[] }): Relation<Suffixed<T, S, Ex>> {\n    return suffix(this as any, sfx, options as any) as unknown as Relation<Suffixed<T, S, Ex>>;\n  }\n\n  // === Set operators ===\n\n  union(right: RelationOperand<T>): Relation<T> {\n    return union(this as any, right as any) as unknown as Relation<T>;\n  }\n\n  minus(right: RelationOperand<T>): Relation<T> {\n    return minus(this as any, right as any) as unknown as Relation<T>;\n  }\n\n  intersect(right: RelationOperand<T>): Relation<T> {\n    return intersect(this as any, right as any) as unknown as Relation<T>;\n  }\n\n  // === Semi-join operators ===\n\n  matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T> {\n    return matching(this as any, right as any, keys as any) as unknown as Relation<T>;\n  }\n\n  not_matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T> {\n    return not_matching(this as any, right as any, keys as any) as unknown as Relation<T>;\n  }\n\n  // === Join operators ===\n\n  join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<Joined<T, R>> {\n    return join(this as any, right as any, keys as any) as unknown as Relation<Joined<T, R>>;\n  }\n\n  left_join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<LeftJoined<T, R>> {\n    return left_join(this as any, right as any, keys as any) as unknown as Relation<LeftJoined<T, R>>;\n  }\n\n  cross_product<R>(right: RelationOperand<R>): Relation<T & R> {\n    return cross_product(this as any, right as any) as unknown as Relation<T & R>;\n  }\n\n  cross_join<R>(right: RelationOperand<R>): Relation<T & R> {\n    return cross_product(this as any, right as any) as unknown as Relation<T & R>;\n  }\n\n  // === Nesting operators ===\n\n  image<R, As extends string>(right: RelationOperand<R>, as: As, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T & Record<As, Relation<Omit<R, keyof T & keyof R>>>> {\n    return image(this as any, right as any, as, keys as any) as unknown as Relation<T & Record<As, Relation<Omit<R, keyof T & keyof R>>>>;\n  }\n\n  group<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Omit<T, K> & Record<As, Relation<Pick<T, K>>>> {\n    return group(this as any, attrs as AttrName[], as) as unknown as Relation<Omit<T, K> & Record<As, Relation<Pick<T, K>>>>;\n  }\n\n  ungroup<K extends keyof T>(attr: K): Relation<Ungrouped<T, K>> {\n    return ungroup(this as any, attr as AttrName) as unknown as Relation<Ungrouped<T, K>>;\n  }\n\n  wrap<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Wrapped<T, K, As>> {\n    return wrap(this as any, attrs as AttrName[], as) as unknown as Relation<Wrapped<T, K, As>>;\n  }\n\n  unwrap<K extends keyof T>(attr: K): Relation<Unwrapped<T, K>> {\n    return unwrap(this as any, attr as AttrName) as unknown as Relation<Unwrapped<T, K>>;\n  }\n\n  // === Aggregation ===\n\n  summarize<By extends keyof T, Aggs extends Record<string, unknown>>(by: By[], aggs: Aggs): Relation<Pick<T, By> & AggregatorResults<Aggs>> {\n    return summarize(this as any, by as AttrName[], aggs as any) as unknown as Relation<Pick<T, By> & AggregatorResults<Aggs>>;\n  }\n\n  // === Transform ===\n\n  transform(t: Transformation): Relation<T> {\n    return transform(this as any, t) as unknown as Relation<T>;\n  }\n\n  // === Dynamic ===\n\n  autowrap(options?: AutowrapOptions): Relation<Tuple> {\n    return autowrap(this as any, options) as Relation<Tuple>;\n  }\n\n  // === Non-relational ===\n\n  one(): T {\n    return one(this as any) as T;\n  }\n\n  toArray(): T[] {\n    return this.tuples;\n  }\n\n  yByX<Y extends keyof T, X extends keyof T>(y: Y, x: X): Record<T[X] & PropertyKey, T[Y]> {\n    return yByX(this as any, y as AttrName, x as AttrName) as Record<T[X] & PropertyKey, T[Y]>;\n  }\n\n  isEqual(right: any): boolean {\n    return isEqual(this as any, right as any);\n  }\n\n  // === Display ===\n\n  toText(options?: TextOptions): string {\n    return toText(this as any, options);\n  }\n\n}\n","import { OperationalOperand, Relation, RelationOperand, Renaming, RenamingFunc, Tuple, JoinKeys, AttrName } from \"@/types\";\nimport { MemoryRelation } from '@/sync/Relation';\nimport { isRelation } from \"./isRelation\";\n\nconst valueKey = (value: unknown): unknown => {\n  if (isRelation(value)) {\n    // For nested relations, convert to sorted array of tuple keys for comparison\n    const tuples = (value as Relation).toArray();\n    const keys = tuples.map(t => tupleKey(t)).sort();\n    return keys;\n  }\n  return value;\n}\n\n/**\n * Generates a unique string key for a tuple, used for equality comparison and deduplication.\n * Handles nested relations by converting them to sorted tuple keys.\n *\n * @example\n * tupleKey({ name: 'Alice', age: 30 })\n * // => '[[\"age\",30],[\"name\",\"Alice\"]]'\n *\n * @example\n * tupleKey({ id: 1, items: Bmg([{ x: 1 }, { x: 2 }]) })\n * // => '[[\"id\",1],[\"items\",[...]]]' (nested relation converted to sorted keys)\n */\nexport const tupleKey = (tuple: Tuple): string => {\n  const entries = Object.entries(tuple).map(([k, v]) => [k, valueKey(v)]);\n  return JSON.stringify(entries.sort(([a], [b]) => (a as string).localeCompare(b as string)));\n}\n\n/**\n * Removes duplicate tuples from an array, preserving order of first occurrence.\n * Uses tupleKey() for equality comparison.\n *\n * @example\n * deduplicate([\n *   { id: 1, name: 'Alice' },\n *   { id: 2, name: 'Bob' },\n *   { id: 1, name: 'Alice' },  // duplicate\n * ])\n * // => [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]\n */\nexport const deduplicate = (tuples: Tuple[]): Tuple[] => {\n  const seen = new Set<string>();\n  const result: Tuple[] = [];\n  for (const tuple of tuples) {\n    const key = tupleKey(tuple);\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(tuple);\n    }\n  }\n  return result;\n}\n\n/**\n * Converts a RelationOperand (Relation or Tuple[]) to an OperationalOperand\n * that provides a uniform interface for iteration and output.\n *\n * @example\n * // With array input, output remains array\n * const op = toOperationalOperand([{ id: 1 }]);\n * [...op.tuples()];        // => [{ id: 1 }]\n * op.output([{ id: 2 }]);  // => [{ id: 2 }]\n *\n * @example\n * // With Relation input, output is a new Relation\n * const op = toOperationalOperand(Bmg([{ id: 1 }]));\n * [...op.tuples()];        // => [{ id: 1 }]\n * op.output([{ id: 2 }]);  // => Bmg([{ id: 2 }])\n */\nexport const toOperationalOperand = (operand: RelationOperand): OperationalOperand => {\n  if (Array.isArray(operand)) {\n    return {\n      tuples: () => operand,\n      output: (tuples) => tuples,\n    };\n  } else if (isRelation(operand)) {\n    return {\n      tuples: () => (operand as Relation).toArray(),\n      output: (tuples) => new MemoryRelation(tuples),\n    };\n  } else {\n    throw `Unable to iterate ${operand}`\n  }\n}\n\n/**\n * Converts a Renaming (object or function) to a RenamingFunc.\n *\n * @example\n * // Object renaming\n * const fn = toRenamingFunc({ name: 'fullName', age: 'years' });\n * fn('name');  // => 'fullName'\n * fn('age');   // => 'years'\n * fn('other'); // => 'other' (unchanged)\n *\n * @example\n * // Function renaming (passed through)\n * const fn = toRenamingFunc(attr => attr.toUpperCase());\n * fn('name'); // => 'NAME'\n */\nexport const toRenamingFunc = (renaming: Renaming): RenamingFunc => {\n  if (typeof(renaming) === 'function') {\n    return renaming;\n  } else {\n    return (attr) => renaming[attr] || attr;\n  }\n}\n\nexport const error = (msg: string) => {\n  throw(msg);\n}\n\n// Join helpers\n\n/**\n * Finds attribute names that exist in both left and right tuple arrays.\n * Used for natural joins when no explicit keys are provided.\n *\n * @example\n * const left = [{ id: 1, name: 'Alice', city: 'NYC' }];\n * const right = [{ city: 'NYC', country: 'USA' }];\n * getCommonAttrs(left, right);\n * // => ['city']\n *\n * @example\n * const left = [{ a: 1, b: 2 }];\n * const right = [{ b: 2, c: 3 }];\n * getCommonAttrs(left, right);\n * // => ['b']\n */\nexport const getCommonAttrs = (left: Tuple[], right: Tuple[]): AttrName[] => {\n  if (left.length === 0 || right.length === 0) return [];\n  const leftAttrs = new Set(Object.keys(left[0]));\n  const rightAttrs = Object.keys(right[0]);\n  return rightAttrs.filter(attr => leftAttrs.has(attr));\n}\n\n/**\n * Normalizes JoinKeys to a Record<AttrName, AttrName> mapping left attrs to right attrs.\n *\n * @example\n * // undefined => use common attributes\n * normalizeKeys(undefined, [{ id: 1, city: 'NYC' }], [{ city: 'NYC' }]);\n * // => { city: 'city' }\n *\n * @example\n * // Array of common attribute names\n * normalizeKeys(['city', 'country'], leftTuples, rightTuples);\n * // => { city: 'city', country: 'country' }\n *\n * @example\n * // Object mapping left attr to right attr\n * normalizeKeys({ city: 'location' }, leftTuples, rightTuples);\n * // => { city: 'location' }\n */\nexport const normalizeKeys = (keys: JoinKeys | undefined, leftTuples: Tuple[], rightTuples: Tuple[]): Record<AttrName, AttrName> => {\n  if (!keys) {\n    const common = getCommonAttrs(leftTuples, rightTuples);\n    return common.reduce((acc, attr) => {\n      acc[attr] = attr;\n      return acc;\n    }, {} as Record<AttrName, AttrName>);\n  }\n  if (Array.isArray(keys)) {\n    return keys.reduce((acc, attr) => {\n      acc[attr] = attr;\n      return acc;\n    }, {} as Record<AttrName, AttrName>);\n  }\n  return keys;\n}\n\n/**\n * Checks if two tuples match on the specified key mapping.\n *\n * @example\n * const keyMap = { city: 'location' };\n * tuplesMatch({ id: 1, city: 'NYC' }, { location: 'NYC', pop: 8 }, keyMap);\n * // => true (left.city === right.location)\n *\n * @example\n * const keyMap = { city: 'city' };\n * tuplesMatch({ city: 'NYC' }, { city: 'LA' }, keyMap);\n * // => false\n */\nexport const tuplesMatch = (left: Tuple, right: Tuple, keyMap: Record<AttrName, AttrName>): boolean => {\n  for (const [leftAttr, rightAttr] of Object.entries(keyMap)) {\n    if (left[leftAttr] !== right[rightAttr]) return false;\n  }\n  return true;\n}\n\n/**\n * Creates a string key from a tuple's join attributes for fast Set-based lookups.\n * Used by matching/not_matching for efficient semi-join operations.\n *\n * @example\n * const keyMap = { first: 'fname', last: 'lname' };\n *\n * // Left side uses left attr names (keys of keyMap)\n * matchKey({ id: 1, first: 'John', last: 'Doe' }, keyMap, 'left');\n * // => '\"John\"|\"Doe\"'\n *\n * // Right side uses right attr names (values of keyMap)\n * matchKey({ fname: 'John', lname: 'Doe', age: 30 }, keyMap, 'right');\n * // => '\"John\"|\"Doe\"'\n */\nexport const matchKey = (tuple: Tuple, keyMap: Record<AttrName, AttrName>, side: 'left' | 'right'): string => {\n  const attrs = side === 'left' ? Object.keys(keyMap) : Object.values(keyMap);\n  const values = attrs.map(attr => JSON.stringify(tuple[attr]));\n  return values.join('|');\n}\n\n/**\n * Removes join key attributes from a right tuple when merging.\n * Used to avoid duplicate columns in join results.\n *\n * @example\n * const keyMap = { city: 'location' };\n * projectOutKeys({ location: 'NYC', country: 'USA', pop: 8 }, keyMap);\n * // => { country: 'USA', pop: 8 }  (location removed)\n *\n * @example\n * const keyMap = { a: 'a', b: 'b' };\n * projectOutKeys({ a: 1, b: 2, c: 3 }, keyMap);\n * // => { c: 3 }  (a and b removed)\n */\nexport const projectOutKeys = (tuple: Tuple, keyMap: Record<AttrName, AttrName>): Tuple => {\n  const rightKeys = new Set(Object.values(keyMap));\n  const result: Tuple = {};\n  for (const [attr, value] of Object.entries(tuple)) {\n    if (!rightKeys.has(attr)) {\n      result[attr] = value;\n    }\n  }\n  return result;\n}\n","import { toPredicateFunc } from \"../../support/toPredicateFunc\";\nimport { RelationOperand, Predicate, Tuple } from \"../../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const restrict = (operand: RelationOperand, p: Predicate): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const f = toPredicateFunc(p)\n  const kept: Tuple[] = [];\n  for (const tuple of iterable) {\n    if (f(tuple)) kept.push(tuple);\n  }\n  return op.output(kept)\n}\n","import { toPredicateFunc } from \"../../support/toPredicateFunc\";\nimport { RelationOperand, Predicate, Tuple } from \"../../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const exclude = (operand: RelationOperand, p: Predicate): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const f = toPredicateFunc(p)\n  const kept: Tuple[] = [];\n  for (const tuple of iterable) {\n    if (!f(tuple)) kept.push(tuple);\n  }\n  return op.output(kept)\n}\n","import { RelationOperand, Tuple } from \"../../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const constants = (operand: RelationOperand, consts: Tuple): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const result: Tuple[] = [];\n  for (const tuple of iterable) {\n    result.push({ ...tuple, ...consts });\n  }\n  return op.output(result)\n}\n","import { RelationOperand, Renaming, Tuple } from \"../../types\";\nimport { toOperationalOperand, toRenamingFunc } from \"./_helpers\";\n\nexport const rename = (operand: RelationOperand, renaming: Renaming): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const renamingFunc = toRenamingFunc(renaming)\n  const result: Tuple[] = [];\n  for (const tuple of iterable) {\n    const renamed = Object.keys(tuple).reduce((memo, attr) => {\n      memo[renamingFunc(attr)] = tuple[attr];\n      return memo;\n    }, {})\n    result.push(renamed);\n  }\n  return op.output(result)\n}\n","import { PrefixOptions, RelationOperand } from \"../../types\";\nimport { rename } from \"./rename\";\n\nexport const prefix = (operand: RelationOperand, pfx: string, options?: PrefixOptions): RelationOperand => {\n  const except = new Set(options?.except ?? []);\n  return rename(operand, (attr) => except.has(attr) ? attr : `${pfx}${attr}`);\n}\n","import { RelationOperand, SuffixOptions } from \"../../types\";\nimport { rename } from \"./rename\";\n\nexport const suffix = (operand: RelationOperand, sfx: string, options?: SuffixOptions): RelationOperand => {\n  const except = new Set(options?.except ?? []);\n  return rename(operand, (attr) => except.has(attr) ? attr : `${attr}${sfx}`);\n}\n","import { RelationOperand, AttrName, Tuple } from \"../../types\";\nimport { toOperationalOperand, deduplicate } from \"./_helpers\";\n\nexport const project = (operand: RelationOperand, attrs: AttrName[]): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const result: Tuple[] = [];\n  for (const tuple of iterable) {\n    const projected = attrs.reduce((memo, attr) => {\n      if (attr in tuple) {\n        memo[attr] = tuple[attr];\n      }\n      return memo;\n    }, {} as Tuple);\n    result.push(projected);\n  }\n  return op.output(deduplicate(result));\n}\n","import { RelationOperand, AttrName, Tuple } from \"../../types\";\nimport { toOperationalOperand, deduplicate } from \"./_helpers\";\n\nexport const allbut = (operand: RelationOperand, attrs: AttrName[]): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const excluded = new Set(attrs);\n  const result: Tuple[] = [];\n  for (const tuple of iterable) {\n    const projected = Object.keys(tuple).reduce((memo, attr) => {\n      if (!excluded.has(attr)) {\n        memo[attr] = tuple[attr];\n      }\n      return memo;\n    }, {} as Tuple);\n    result.push(projected);\n  }\n  return op.output(deduplicate(result));\n}\n","import { RelationOperand, Extension, Tuple } from \"../../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const extend = (operand: RelationOperand, extension: Extension): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const result: Tuple[] = [];\n  for (const tuple of iterable) {\n    const extended = { ...tuple };\n    for (const [attr, spec] of Object.entries(extension)) {\n      if (typeof spec === 'function') {\n        extended[attr] = spec(tuple);\n      } else {\n        extended[attr] = tuple[spec];\n      }\n    }\n    result.push(extended);\n  }\n  return op.output(result);\n}\n","import { RelationOperand, Tuple } from \"../../types\";\nimport { toOperationalOperand, tupleKey } from \"./_helpers\";\n\nexport const union = (left: RelationOperand, right: RelationOperand): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n  const seen = new Set<string>();\n  const result: Tuple[] = [];\n\n  for (const tuple of opLeft.tuples()) {\n    const key = tupleKey(tuple);\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(tuple);\n    }\n  }\n\n  for (const tuple of opRight.tuples()) {\n    const key = tupleKey(tuple);\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(tuple);\n    }\n  }\n\n  return opLeft.output(result);\n}\n","import { RelationOperand, Tuple } from \"../../types\";\nimport { toOperationalOperand, tupleKey } from \"./_helpers\";\n\nexport const minus = (left: RelationOperand, right: RelationOperand): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n\n  const rightKeys = new Set<string>();\n  for (const tuple of opRight.tuples()) {\n    rightKeys.add(tupleKey(tuple));\n  }\n\n  const seen = new Set<string>();\n  const result: Tuple[] = [];\n  for (const tuple of opLeft.tuples()) {\n    const key = tupleKey(tuple);\n    if (!rightKeys.has(key) && !seen.has(key)) {\n      seen.add(key);\n      result.push(tuple);\n    }\n  }\n\n  return opLeft.output(result);\n}\n","import { RelationOperand, Tuple } from \"../../types\";\nimport { toOperationalOperand, tupleKey } from \"./_helpers\";\n\nexport const intersect = (left: RelationOperand, right: RelationOperand): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n\n  const rightKeys = new Set<string>();\n  for (const tuple of opRight.tuples()) {\n    rightKeys.add(tupleKey(tuple));\n  }\n\n  const seen = new Set<string>();\n  const result: Tuple[] = [];\n  for (const tuple of opLeft.tuples()) {\n    const key = tupleKey(tuple);\n    if (rightKeys.has(key) && !seen.has(key)) {\n      seen.add(key);\n      result.push(tuple);\n    }\n  }\n\n  return opLeft.output(result);\n}\n","import { RelationOperand, JoinKeys, Tuple } from \"../../types\";\nimport { toOperationalOperand, normalizeKeys, matchKey } from \"./_helpers\";\n\nexport const matching = (left: RelationOperand, right: RelationOperand, keys?: JoinKeys): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n  const leftTuples = [...opLeft.tuples()];\n  const rightTuples = [...opRight.tuples()];\n  const keyMap = normalizeKeys(keys, leftTuples, rightTuples);\n\n  const rightKeys = new Set<string>();\n  for (const tuple of rightTuples) {\n    rightKeys.add(matchKey(tuple, keyMap, 'right'));\n  }\n\n  const result: Tuple[] = [];\n  for (const tuple of leftTuples) {\n    if (rightKeys.has(matchKey(tuple, keyMap, 'left'))) {\n      result.push(tuple);\n    }\n  }\n\n  return opLeft.output(result);\n}\n","import { RelationOperand, JoinKeys, Tuple } from \"../../types\";\nimport { toOperationalOperand, normalizeKeys, matchKey } from \"./_helpers\";\n\nexport const not_matching = (left: RelationOperand, right: RelationOperand, keys?: JoinKeys): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n  const leftTuples = [...opLeft.tuples()];\n  const rightTuples = [...opRight.tuples()];\n  const keyMap = normalizeKeys(keys, leftTuples, rightTuples);\n\n  const rightKeys = new Set<string>();\n  for (const tuple of rightTuples) {\n    rightKeys.add(matchKey(tuple, keyMap, 'right'));\n  }\n\n  const result: Tuple[] = [];\n  for (const tuple of leftTuples) {\n    if (!rightKeys.has(matchKey(tuple, keyMap, 'left'))) {\n      result.push(tuple);\n    }\n  }\n\n  return opLeft.output(result);\n}\n","import { RelationOperand, JoinKeys, Tuple, AttrName } from \"../../types\";\nimport { toOperationalOperand, normalizeKeys, tuplesMatch, projectOutKeys } from \"./_helpers\";\n\nconst mergeTuples = (left: Tuple, right: Tuple, keyMap: Record<AttrName, AttrName>): Tuple => {\n  return { ...left, ...projectOutKeys(right, keyMap) };\n}\n\nexport const join = (left: RelationOperand, right: RelationOperand, keys?: JoinKeys): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n  const leftTuples = [...opLeft.tuples()];\n  const rightTuples = [...opRight.tuples()];\n  const keyMap = normalizeKeys(keys, leftTuples, rightTuples);\n  const result: Tuple[] = [];\n\n  for (const leftTuple of leftTuples) {\n    for (const rightTuple of rightTuples) {\n      if (tuplesMatch(leftTuple, rightTuple, keyMap)) {\n        result.push(mergeTuples(leftTuple, rightTuple, keyMap));\n      }\n    }\n  }\n\n  return opLeft.output(result);\n}\n","import { RelationOperand, JoinKeys, Tuple, AttrName } from \"../../types\";\nimport { toOperationalOperand, normalizeKeys, tuplesMatch } from \"./_helpers\";\n\nconst getRightAttrs = (rightTuples: Tuple[], keyMap: Record<AttrName, AttrName>): AttrName[] => {\n  if (rightTuples.length === 0) return [];\n  const rightKeys = new Set(Object.values(keyMap));\n  return Object.keys(rightTuples[0]).filter(attr => !rightKeys.has(attr));\n}\n\nconst mergeTuples = (left: Tuple, right: Tuple | null, rightAttrs: AttrName[]): Tuple => {\n  const result = { ...left };\n  for (const attr of rightAttrs) {\n    result[attr] = right ? right[attr] : null;\n  }\n  return result;\n}\n\nexport const left_join = (left: RelationOperand, right: RelationOperand, keys?: JoinKeys): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n  const leftTuples = [...opLeft.tuples()];\n  const rightTuples = [...opRight.tuples()];\n  const keyMap = normalizeKeys(keys, leftTuples, rightTuples);\n  const rightAttrs = getRightAttrs(rightTuples, keyMap);\n  const result: Tuple[] = [];\n\n  for (const leftTuple of leftTuples) {\n    let matched = false;\n    for (const rightTuple of rightTuples) {\n      if (tuplesMatch(leftTuple, rightTuple, keyMap)) {\n        result.push(mergeTuples(leftTuple, rightTuple, rightAttrs));\n        matched = true;\n      }\n    }\n    if (!matched) {\n      result.push(mergeTuples(leftTuple, null, rightAttrs));\n    }\n  }\n\n  return opLeft.output(result);\n}\n","import { RelationOperand, Tuple } from \"../../types\";\nimport { toOperationalOperand, deduplicate } from \"./_helpers\";\n\nexport const cross_product = (left: RelationOperand, right: RelationOperand): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n  const leftTuples = [...opLeft.tuples()];\n  const rightTuples = [...opRight.tuples()];\n  const result: Tuple[] = [];\n\n  for (const l of leftTuples) {\n    for (const r of rightTuples) {\n      result.push({ ...r, ...l });\n    }\n  }\n\n  return opLeft.output(deduplicate(result));\n}\n\nexport { cross_product as cross_join };\n","import { RelationOperand, JoinKeys, Tuple, AttrName } from \"../../types\";\nimport { toOperationalOperand, normalizeKeys, tuplesMatch, projectOutKeys } from \"./_helpers\";\nimport { MemoryRelation } from \"@/sync/Relation\";\n\nexport const image = (left: RelationOperand, right: RelationOperand, as: AttrName, keys?: JoinKeys): RelationOperand => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n  const leftTuples = [...opLeft.tuples()];\n  const rightTuples = [...opRight.tuples()];\n  const keyMap = normalizeKeys(keys, leftTuples, rightTuples);\n  const result: Tuple[] = [];\n\n  for (const leftTuple of leftTuples) {\n    const matches: Tuple[] = [];\n    for (const rightTuple of rightTuples) {\n      if (tuplesMatch(leftTuple, rightTuple, keyMap)) {\n        matches.push(projectOutKeys(rightTuple, keyMap));\n      }\n    }\n    result.push({\n      ...leftTuple,\n      [as]: new MemoryRelation(matches)\n    });\n  }\n\n  return opLeft.output(result);\n}\n","import { RelationOperand, AttrName, Tuple, Aggregator, Aggregators } from \"../../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nconst groupKey = (tuple: Tuple, by: AttrName[]): string => {\n  const keyParts = by.map(attr => JSON.stringify(tuple[attr]));\n  return keyParts.join('|');\n}\n\nconst pickAttrs = (tuple: Tuple, attrs: AttrName[]): Tuple => {\n  return attrs.reduce((acc, attr) => {\n    acc[attr] = tuple[attr];\n    return acc;\n  }, {} as Tuple);\n}\n\nconst applyAggregator = (tuples: Tuple[], agg: Aggregator): unknown => {\n  if (typeof agg === 'function') {\n    return agg(tuples);\n  }\n\n  const spec = typeof agg === 'string' ? { op: agg, attr: '' } : agg;\n  const { op, attr } = spec;\n\n  switch (op) {\n    case 'count':\n      return tuples.length;\n\n    case 'sum': {\n      return tuples.reduce((sum, t) => sum + (Number(t[attr]) || 0), 0);\n    }\n\n    case 'min': {\n      const values = tuples.map(t => t[attr]).filter(v => v !== undefined && v !== null);\n      return values.length > 0 ? Math.min(...values.map(Number)) : null;\n    }\n\n    case 'max': {\n      const values = tuples.map(t => t[attr]).filter(v => v !== undefined && v !== null);\n      return values.length > 0 ? Math.max(...values.map(Number)) : null;\n    }\n\n    case 'avg': {\n      const values = tuples.map(t => Number(t[attr])).filter(v => !isNaN(v));\n      return values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : null;\n    }\n\n    case 'collect': {\n      return tuples.map(t => t[attr]);\n    }\n\n    default:\n      throw new Error(`Unknown aggregator: ${op}`);\n  }\n}\n\nexport const summarize = (\n  operand: RelationOperand,\n  by: AttrName[],\n  aggs: Aggregators\n): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const tuples = [...op.tuples()];\n\n  // Group tuples\n  const groups = new Map<string, Tuple[]>();\n  for (const tuple of tuples) {\n    const key = groupKey(tuple, by);\n    if (!groups.has(key)) {\n      groups.set(key, []);\n    }\n    groups.get(key)!.push(tuple);\n  }\n\n  // Apply aggregators to each group\n  const result: Tuple[] = [];\n  for (const groupTuples of groups.values()) {\n    const row: Tuple = pickAttrs(groupTuples[0], by);\n    for (const [resultAttr, agg] of Object.entries(aggs)) {\n      row[resultAttr] = applyAggregator(groupTuples, agg);\n    }\n    result.push(row);\n  }\n\n  return op.output(result);\n}\n","import { RelationOperand, AttrName, Tuple } from \"../../types\";\nimport { toOperationalOperand } from \"./_helpers\";\nimport { MemoryRelation } from \"@/sync/Relation\";\n\nconst groupKey = (tuple: Tuple, byAttrs: AttrName[]): string => {\n  const keyParts = byAttrs.map(attr => JSON.stringify(tuple[attr]));\n  return keyParts.join('|');\n}\n\nconst pickAttrs = (tuple: Tuple, attrs: AttrName[]): Tuple => {\n  return attrs.reduce((acc, attr) => {\n    acc[attr] = tuple[attr];\n    return acc;\n  }, {} as Tuple);\n}\n\nexport const group = (operand: RelationOperand, attrs: AttrName[], as: AttrName): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const tuples = [...op.tuples()];\n\n  if (tuples.length === 0) {\n    return op.output([]);\n  }\n\n  // Determine which attributes to keep at the top level (all except grouped ones)\n  const allAttrs = Object.keys(tuples[0]);\n  const groupedSet = new Set(attrs);\n  const byAttrs = allAttrs.filter(a => !groupedSet.has(a));\n\n  // Group tuples\n  const groups = new Map<string, { base: Tuple, nested: Tuple[] }>();\n  for (const tuple of tuples) {\n    const key = groupKey(tuple, byAttrs);\n    if (!groups.has(key)) {\n      groups.set(key, {\n        base: pickAttrs(tuple, byAttrs),\n        nested: []\n      });\n    }\n    groups.get(key)!.nested.push(pickAttrs(tuple, attrs));\n  }\n\n  // Build result with nested relations\n  const result: Tuple[] = [];\n  for (const { base, nested } of groups.values()) {\n    result.push({\n      ...base,\n      [as]: new MemoryRelation(nested)\n    });\n  }\n\n  return op.output(result);\n}\n","import { RelationOperand, AttrName, Tuple, Relation } from \"../../types\";\nimport { toOperationalOperand } from \"./_helpers\";\nimport { isRelation } from \"./isRelation\";\n\nconst toTupleArray = (value: unknown): Tuple[] => {\n  if (isRelation(value)) {\n    return (value as Relation).toArray();\n  }\n  if (Array.isArray(value)) {\n    return value;\n  }\n  throw new Error(`Value is not a relation or array`);\n}\n\nexport const ungroup = (operand: RelationOperand, attr: AttrName): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const tuples = [...op.tuples()];\n  const result: Tuple[] = [];\n\n  for (const tuple of tuples) {\n    const nested = toTupleArray(tuple[attr]);\n\n    // Get base attributes (all except the grouped one)\n    const base: Tuple = {};\n    for (const [key, value] of Object.entries(tuple)) {\n      if (key !== attr) {\n        base[key] = value;\n      }\n    }\n\n    // Flatten each nested tuple\n    for (const nestedTuple of nested) {\n      result.push({\n        ...base,\n        ...nestedTuple\n      });\n    }\n  }\n\n  return op.output(result);\n}\n","import { RelationOperand, AttrName, Tuple } from \"../../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const wrap = (operand: RelationOperand, attrs: AttrName[], as: AttrName): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const wrappedSet = new Set(attrs);\n  const result: Tuple[] = [];\n\n  for (const tuple of iterable) {\n    const wrapped: Tuple = {};\n    const remaining: Tuple = {};\n\n    for (const [key, value] of Object.entries(tuple)) {\n      if (wrappedSet.has(key)) {\n        wrapped[key] = value;\n      } else {\n        remaining[key] = value;\n      }\n    }\n\n    result.push({\n      ...remaining,\n      [as]: wrapped\n    });\n  }\n\n  return op.output(result);\n}\n","import { RelationOperand, AttrName, Tuple } from \"../../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const unwrap = (operand: RelationOperand, attr: AttrName): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const result: Tuple[] = [];\n\n  for (const tuple of iterable) {\n    const wrapped = tuple[attr] as Tuple;\n    if (typeof wrapped !== 'object' || wrapped === null || Array.isArray(wrapped)) {\n      throw new Error(`Attribute '${attr}' is not a tuple (object)`);\n    }\n\n    const unwrapped: Tuple = {};\n    for (const [key, value] of Object.entries(tuple)) {\n      if (key !== attr) {\n        unwrapped[key] = value;\n      }\n    }\n\n    result.push({\n      ...unwrapped,\n      ...wrapped\n    });\n  }\n\n  return op.output(result);\n}\n","import { AutowrapOptions, RelationOperand, Tuple } from \"../../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const autowrap = (operand: RelationOperand, options?: AutowrapOptions): RelationOperand => {\n  const sep = options?.separator ?? '_';\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const result: Tuple[] = [];\n\n  for (const tuple of iterable) {\n    const wrapped: Tuple = {};\n    for (const [attr, value] of Object.entries(tuple)) {\n      const parts = attr.split(sep);\n      if (parts.length === 1) {\n        wrapped[attr] = value;\n      } else {\n        const [prefix, ...rest] = parts;\n        wrapped[prefix] = wrapped[prefix] ?? {};\n        (wrapped[prefix] as Tuple)[rest.join(sep)] = value;\n      }\n    }\n    result.push(wrapped);\n  }\n\n  return op.output(result);\n}\n","import { RelationOperand, Transformation, Tuple } from \"../../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const transform = (operand: RelationOperand, transformation: Transformation): RelationOperand => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const result: Tuple[] = [];\n\n  for (const tuple of iterable) {\n    const transformed: Tuple = {};\n\n    for (const [attr, value] of Object.entries(tuple)) {\n      transformed[attr] = applyTransformation(value, attr, transformation);\n    }\n\n    result.push(transformed);\n  }\n\n  return op.output(result);\n}\n\nconst applyTransformation = (value: unknown, attr: string, transformation: Transformation): unknown => {\n  if (typeof transformation === 'function') {\n    // Single function - apply to all values\n    return transformation(value);\n  } else if (Array.isArray(transformation)) {\n    // Array of functions - chain them\n    return transformation.reduce((v, fn) => fn(v), value);\n  } else {\n    // Object with attr-specific transformers\n    const fn = transformation[attr];\n    if (fn) {\n      if (Array.isArray(fn)) {\n        return fn.reduce((v, f) => f(v), value);\n      }\n      return fn(value);\n    }\n    return value;\n  }\n}\n","import { toOperationalOperand, tupleKey } from \"./_helpers\";\n\nexport const isEqual = (left: any, right: any): boolean => {\n  const opLeft = toOperationalOperand(left);\n  const opRight = toOperationalOperand(right);\n\n  const leftKeys = new Set<string>();\n  for (const tuple of opLeft.tuples()) {\n    leftKeys.add(tupleKey(tuple));\n  }\n\n  const rightKeys = new Set<string>();\n  for (const tuple of opRight.tuples()) {\n    rightKeys.add(tupleKey(tuple));\n  }\n\n  if (leftKeys.size !== rightKeys.size) {\n    return false;\n  }\n\n  for (const key of leftKeys) {\n    if (!rightKeys.has(key)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","import { RelationOperand, Tuple } from \"../../types\";\nimport { toOperationalOperand, error } from \"./_helpers\";\n\nexport const one = (operand: RelationOperand): Tuple => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  let tuple;\n  for (const t of iterable) {\n    if (tuple) {\n      return error('More than one tuple found');\n    } else {\n      tuple = t;\n    }\n  }\n  if (tuple) return tuple;\n  return error('Relation is empty');\n}\n","import { AttrName, RelationOperand, Tuple } from \"../../types\";\nimport { toOperationalOperand } from \"./_helpers\";\n\nexport const yByX = (operand: RelationOperand, y: AttrName, x: AttrName): Tuple => {\n  const op = toOperationalOperand(operand);\n  const iterable = op.tuples();\n  const hash = {};\n  for (const tuple of iterable) {\n    hash[`${tuple[x]}`] = tuple[y];\n  }\n  return hash;\n}\n","export * from './sync/operators';\nexport * from './types';\nexport { LIB_DEFINITIONS } from './lib-definitions';\nexport { toText } from './writer';\n\nimport { MemoryRelation } from './sync/Relation';\nimport { isRelation } from './sync/operators';\n\n/**\n * Creates a new in-memory relation from an array of tuples.\n *\n * @typeParam T - The tuple type. Inferred from input or explicitly provided.\n *\n * @example\n * // Untyped usage (backwards compatible)\n * const r = Bmg([{ id: 1, name: 'Alice' }]);\n *\n * @example\n * // Typed usage with explicit type parameter\n * interface Person { id: number; name: string }\n * const r = Bmg<Person>([{ id: 1, name: 'Alice' }]);\n * r.project(['id']);  // Autocomplete suggests 'id' | 'name'\n *\n * @example\n * // Type is inferred from input\n * const r = Bmg([{ id: 1, name: 'Alice' }] as const);\n */\nexport function Bmg<T>(tuples: T[]): MemoryRelation<T> {\n  return new MemoryRelation<T>(tuples);\n}\n\nBmg.isRelation = isRelation;\n\n/**\n * DEE - The relation with no attributes and exactly one tuple.\n * This is the identity element for natural join.\n */\nexport const DEE = new MemoryRelation<Record<string, never>>([{}]);\n\n/**\n * DUM - The relation with no attributes and no tuples.\n * This is the identity element for union.\n */\nexport const DUM = new MemoryRelation<Record<string, never>>([]);\n","// Auto-generated from types.ts\n// Run 'npm run generate:lib-definitions' to regenerate\n\nexport const LIB_DEFINITIONS = `\n/**\n * Type definitions for Bmg.js relational algebra library.\n *\n * This file defines all types needed for type-safe relational operations:\n * - Base types (AttrName, Tuple)\n * - Utility types for transformations (Renamed, Prefixed, Joined, etc.)\n * - The Relation interface with all operators\n * - Helper types for predicates, extensions, aggregators, etc.\n */\n\n// ============================================================================\n// Base Types\n// ============================================================================\n\n/** Attribute name in a tuple */\ntype AttrName = string\n\n/** A tuple is a record mapping attribute names to values */\ntype Tuple = Record<AttrName, unknown>\n\n// ============================================================================\n// Rename Types\n// ============================================================================\n\n/** Map from old attribute names to new attribute names */\ntype RenameMap<T> = { [K in keyof T]?: string };\n\n/** Transform tuple type by renaming keys according to RenameMap */\ntype Renamed<T, R extends RenameMap<T>> = {\n  [K in keyof T as K extends keyof R ? (R[K] extends string ? R[K] : K) : K]: T[K];\n};\n\n// ============================================================================\n// Prefix/Suffix Types\n// ============================================================================\n\n/** Prefix all keys except those in Except */\ntype Prefixed<T, P extends string, Except extends keyof T = never> = {\n  [K in keyof T as K extends Except ? K : \\`\\${P}\\${K & string}\\`]: T[K];\n};\n\n/** Suffix all keys except those in Except */\ntype Suffixed<T, S extends string, Except extends keyof T = never> = {\n  [K in keyof T as K extends Except ? K : \\`\\${K & string}\\${S}\\`]: T[K];\n};\n\n// ============================================================================\n// Join Types\n// ============================================================================\n\n/** Extract common keys between two tuple types */\ntype CommonKeys<L, R> = Extract<keyof L, keyof R>;\n\n/** Result of inner join: L & R with R's common keys removed */\ntype Joined<L, R> = L & Omit<R, CommonKeys<L, R>>;\n\n/** Result of left join: L & optional R attributes (common keys removed) */\ntype LeftJoined<L, R> = L & Partial<Omit<R, CommonKeys<L, R>>>;\n\n/**\n * Typed join keys for array form: keys must exist on BOTH operands.\n * Example: suppliers.join(parts, ['city']) - 'city' must be a key of both.\n */\ntype TypedJoinKeysArray<L, R> = (keyof L & keyof R & string)[];\n\n/**\n * Typed join keys for object form: maps left keys to right keys.\n * Example: suppliers.join(parts, { sid: 'supplier_id' })\n * - Left key (sid) must exist on L\n * - Right key (supplier_id) must exist on R\n */\ntype TypedJoinKeysObject<L, R> = { [K in keyof L & string]?: keyof R & string };\n\n// ============================================================================\n// Wrap/Unwrap Types\n// ============================================================================\n\n/** Result of wrap: remove wrapped attrs, add nested object */\ntype Wrapped<T, K extends keyof T, As extends string> =\n  Omit<T, K> & Record<As, Pick<T, K>>;\n\n/** Result of unwrap: remove object attr, spread its properties */\ntype Unwrapped<T, K extends keyof T> =\n  T[K] extends Record<string, unknown> ? Omit<T, K> & T[K] : Omit<T, K>;\n\n/** Result of ungroup: remove relation attr, flatten its tuple type */\ntype Ungrouped<T, K extends keyof T> =\n  T[K] extends Relation<infer N> ? Omit<T, K> & N : Omit<T, K>;\n\n// ============================================================================\n// Aggregator Types\n// ============================================================================\n\ntype AggregatorName = 'count' | 'sum' | 'min' | 'max' | 'avg' | 'collect'\ntype AggregatorSpec = { op: AggregatorName, attr: AttrName }\ntype AggregatorFunc = (tuples: Tuple[]) => unknown\ntype Aggregator = AggregatorName | AggregatorSpec | AggregatorFunc\ntype Aggregators = Record<AttrName, Aggregator>\n\n/** Infer result type from aggregator specification */\ntype AggregatorResult<A> =\n  A extends 'count' ? number :\n  A extends { op: 'count' } ? number :\n  A extends { op: 'sum' | 'avg' | 'min' | 'max' } ? number | null :\n  A extends { op: 'collect' } ? unknown[] :\n  A extends (tuples: Tuple[]) => infer R ? R :\n  unknown;\n\n/** Map aggregator definitions to their result types */\ntype AggregatorResults<Aggs extends Record<string, unknown>> = {\n  [K in keyof Aggs]: AggregatorResult<Aggs[K]>;\n};\n\n// ============================================================================\n// Predicate Types\n// ============================================================================\n\n/** Predicate function that receives a typed tuple */\ntype TypedPredicateFunc<T> = (t: T) => boolean\n\n/** Predicate: either a partial tuple for equality matching, or a function */\ntype TypedPredicate<T> = Partial<T> | TypedPredicateFunc<T>\n\n// Legacy predicate types (for backwards compatibility with standalone operators)\ntype PredicateFunc = ((t: Tuple) => any)\ntype Predicate = Tuple | PredicateFunc\n\n// ============================================================================\n// Extension Types\n// ============================================================================\n\n/** Extension function that receives a typed tuple */\ntype TypedExtensionFunc<T, R> = (tuple: T) => R\n\n/** Extension definition: function returning value, or attribute name to copy */\ntype TypedExtension<T, E extends Record<string, unknown>> = {\n  [K in keyof E]: TypedExtensionFunc<T, E[K]> | keyof T;\n}\n\ntype ExtensionFunc = (tuple: Tuple) => unknown\ntype Extension = Record<AttrName, ExtensionFunc | AttrName>\n\n// ============================================================================\n// Other Helper Types\n// ============================================================================\n\ninterface PrefixOptions {\n  except?: AttrName[]\n}\n\ninterface TextOptions {\n  /** Precision for floating point numbers (default: 3) */\n  floatPrecision?: number;\n  /** Maximum width to trim output at */\n  trimAt?: number;\n}\n\ninterface SuffixOptions {\n  except?: AttrName[]\n}\n\ninterface AutowrapOptions {\n  separator?: string\n}\n\ntype Renaming = RenamingObj | RenamingFunc\ntype RenamingFunc = (attr: AttrName) => AttrName\ntype RenamingObj = Record<AttrName, AttrName>\n\ntype JoinKeys = AttrName[] | Record<AttrName, AttrName>\n\ntype TransformFunc = (value: unknown) => unknown\ntype Transformation = TransformFunc | TransformFunc[] | Record<AttrName, TransformFunc | TransformFunc[]>\n\n// ============================================================================\n// Relation Interface\n// ============================================================================\n\n/**\n * Relation interface with generic type parameter for tuple type.\n * Default parameter \\`Tuple\\` ensures backwards compatibility.\n *\n * @typeParam T - The tuple type for this relation. Defaults to \\`Tuple\\` (Record<string, unknown>).\n *\n * @example\n * // Untyped usage (backwards compatible)\n * const r = Bmg([{ id: 1 }]);  // Relation<Tuple>\n *\n * @example\n * // Typed usage with full type safety\n * interface Person { id: number; name: string }\n * const r = Bmg<Person>([{ id: 1, name: 'Alice' }]);\n * r.project(['id']);  // Relation<{ id: number }>\n */\ninterface Relation<T = Tuple> {\n  // === Type-preserving operators ===\n\n  restrict(p: TypedPredicate<T>): Relation<T>\n  where(p: TypedPredicate<T>): Relation<T>\n  exclude(p: TypedPredicate<T>): Relation<T>\n\n  // === Projection operators ===\n\n  project<K extends keyof T>(attrs: K[]): Relation<Pick<T, K>>\n  allbut<K extends keyof T>(attrs: K[]): Relation<Omit<T, K>>\n\n  // === Extension operators ===\n\n  extend<E extends Record<string, unknown>>(e: TypedExtension<T, E>): Relation<T & E>\n  constants<C extends Tuple>(consts: C): Relation<T & C>\n\n  // === Rename operators ===\n\n  rename<R extends RenameMap<T>>(r: R): Relation<Renamed<T, R>>\n  prefix<P extends string, Ex extends keyof T = never>(pfx: P, options?: { except?: Ex[] }): Relation<Prefixed<T, P, Ex>>\n  suffix<S extends string, Ex extends keyof T = never>(sfx: S, options?: { except?: Ex[] }): Relation<Suffixed<T, S, Ex>>\n\n  // === Set operators (require same type) ===\n\n  union(right: RelationOperand<T>): Relation<T>\n  minus(right: RelationOperand<T>): Relation<T>\n  intersect(right: RelationOperand<T>): Relation<T>\n\n  // === Semi-join operators (preserve left type) ===\n\n  matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T>\n  not_matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T>\n\n  // === Join operators ===\n\n  join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<Joined<T, R>>\n  left_join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<LeftJoined<T, R>>\n  cross_product<R>(right: RelationOperand<R>): Relation<T & R>\n  cross_join<R>(right: RelationOperand<R>): Relation<T & R>\n\n  // === Nesting operators ===\n\n  image<R, As extends string>(right: RelationOperand<R>, as: As, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T & Record<As, Relation<Omit<R, keyof T & keyof R>>>>\n  group<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Omit<T, K> & Record<As, Relation<Pick<T, K>>>>\n  ungroup<K extends keyof T>(attr: K): Relation<Ungrouped<T, K>>\n  wrap<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Wrapped<T, K, As>>\n  unwrap<K extends keyof T>(attr: K): Relation<Unwrapped<T, K>>\n\n  // === Aggregation ===\n\n  summarize<By extends keyof T, Aggs extends Aggregators>(by: By[], aggs: Aggs): Relation<Pick<T, By> & AggregatorResults<Aggs>>\n\n  // === Transform ===\n\n  transform(t: Transformation): Relation<T>\n\n  // === Dynamic (loses type precision) ===\n\n  autowrap(options?: AutowrapOptions): Relation<Tuple>\n\n  // === Non-relational ===\n\n  one(): T\n  yByX<Y extends keyof T, X extends keyof T>(y: Y, x: X): Record<T[X] & PropertyKey, T[Y]>\n  toArray(): T[]\n  isEqual(right: any): boolean\n\n  // === Display ===\n\n  toText(options?: TextOptions): string\n}\n\n// ============================================================================\n// Operands\n// ============================================================================\n\ntype RelationOperand<T = Tuple> = Relation<T> | T[]\n\ninterface OperationalOperand<T = Tuple> {\n  tuples(): Iterable<T>\n  output(tuples: T[]): RelationOperand<T>\n}\n\n// ============================================================================\n// Bmg Function Declaration\n// ============================================================================\n\n/** Create a relation from an array of tuples */\ndeclare function Bmg<T>(tuples: T[]): Relation<T>\ndeclare namespace Bmg {\n  function isRelation(op: unknown): boolean\n}\n`\n"],"names":["toPredicateFunc","p","expected","t","Object","keys","every","k","isRelation","op","constructor","MemoryRelation","isTupleLike","Array","isArray","max","x","y","Cell","renderer","value","_textRendering","this","_minWidth","_proto","prototype","_createClass","renderingLines","size","undefined","textRendering","split","map","l","padStart","padEnd","computeTextRendering","r","toString","_this$renderer$option","Number","isInteger","String","precision","options","floatPrecision","toFixed","render","arrayRendering","Date","toISOString","JSON","stringify","_this","length","values","reduce","sum","s","join","key","get","maxLen","line","Row","cells","v","_proto2","minWidths","cell","minWidth","sizes","nbLines","byCell","i","lines","grid","_loop","lineI","lineContent","cellLines","_cellLines$lineI","repeat","push","Table","records","attributes","header","rows","_sizes","_sep","_proto3","eachLine","_regenerator","m","trimAt","_iterator","_step","w","_context","n","_createForOfIteratorHelperLoose","eachLineRaw","done","substring","d","_regeneratorValues","a","_iterator2","_step2","_iterator3","_step3","_context2","sep","row","Symbol","iterator","_callee","_iterator4","_step4","_context3","trimEnd","_step5","result","_iterator5","headerWidths","memo","rowWidths","_rowWidths$i","TextWriter","_proto4","input","output","_iterator6","_step6","tuples","attrs","table","_context4","toArray","tuple","_i","_Object$keys","includes","toText","operand","restrict","where","exclude","project","allbut","extend","e","constants","consts","rename","prefix","pfx","suffix","sfx","union","right","minus","intersect","matching","not_matching","left_join","cross_product","cross_join","image","as","group","ungroup","attr","wrap","unwrap","summarize","by","aggs","transform","autowrap","one","yByX","isEqual","tupleKey","entries","_ref","sort","_ref2","_ref3","localeCompare","deduplicate","seen","Set","has","add","toOperationalOperand","error","msg","normalizeKeys","leftTuples","rightTuples","acc","left","leftAttrs","filter","getCommonAttrs","tuplesMatch","keyMap","_Object$entries","_Object$entries$_i","matchKey","side","projectOutKeys","rightKeys","_i2","_Object$entries2","_Object$entries2$_i","iterable","f","kept","_extends","renaming","renamingFunc","toRenamingFunc","renamed","_options$except","except","projected","excluded","extension","extended","spec","opLeft","opRight","concat","mergeTuples","leftTuple","rightTuple","rightAttrs","getRightAttrs","matched","_extends2","matches","groupKey","pickAttrs","applyAggregator","agg","Math","min","apply","isNaN","b","Error","groups","Map","set","groupTuples","byAttrs","allAttrs","groupedSet","base","nested","_step2$value","toTupleArray","wrappedSet","wrapped","remaining","unwrapped","_options$separator","separator","parts","_wrapped$prefix","rest","_arrayLikeToArray","slice","transformation","transformed","applyTransformation","fn","leftKeys","hash","Bmg","DEE","DUM"],"mappings":"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"}

package/dist/bmg.modern.js

@@ -1,2 +1,2 @@
-const e=e=>{if("function"==typeof e)return e;{const n=e;return e=>Object.keys(n).every(t=>e[t]===n[t])}};class n{constructor(e){this.tuples=void 0,this.tuples=e,this.tuples=e}restrict(e){return l(this,e)}where(e){return l(this,e)}exclude(e){return f(this,e)}project(e){return R(this,e)}allbut(e){return h(this,e)}extend(e){return x(this,e)}constants(e){return d(this,e)}rename(e){return T(this,e)}prefix(e,n){return g(this,e,n)}suffix(e,n){return m(this,e,n)}union(e){return A(this,e)}minus(e){return k(this,e)}intersect(e){return w(this,e)}matching(e,n){return b(this,e,n)}not_matching(e,n){return K(this,e,n)}join(e,n){return j(this,e,n)}left_join(e,n){return v(this,e,n)}cross_product(e){return S(this,e)}cross_join(e){return S(this,e)}image(e,n,t){return P(this,e,n,t)}group(e,n){return _(this,e,n)}ungroup(e){return U(this,e)}wrap(e,n){return C(this,e,n)}unwrap(e){return X(this,e)}summarize(e,n){return F(this,e,n)}transform(e){return z(this,e)}autowrap(e){return q(this,e)}one(){return I(this)}toArray(){return this.tuples}yByX(e,n){return W(this,e,n)}isEqual(e){return H(this,e)}}const t=e=>null!=e&&e.constructor===n,r=e=>{const n=Object.entries(e).map(([e,n])=>{return[e,(o=n,t(o)?o.toArray().map(e=>r(e)).sort():o)];var o});return JSON.stringify(n.sort(([e],[n])=>e.localeCompare(n)))},o=e=>{const n=new Set,t=[];for(const o of e){const e=r(o);n.has(e)||(n.add(e),t.push(o))}return t},s=e=>{if(Array.isArray(e))return{tuples:()=>e,output:e=>e};if(t(e))return{tuples:()=>e.toArray(),output:e=>new n(e)};throw`Unable to iterate ${e}`},a=e=>{throw e},i=(e,n,t)=>e?Array.isArray(e)?e.reduce((e,n)=>(e[n]=n,e),{}):e:((e,n)=>{if(0===e.length||0===n.length)return[];const t=new Set(Object.keys(e[0]));return Object.keys(n[0]).filter(e=>t.has(e))})(n,t).reduce((e,n)=>(e[n]=n,e),{}),u=(e,n,t)=>{for(const[r,o]of Object.entries(t))if(e[r]!==n[o])return!1;return!0},p=(e,n,t)=>("left"===t?Object.keys(n):Object.values(n)).map(n=>JSON.stringify(e[n])).join("|"),c=(e,n)=>{const t=new Set(Object.values(n)),r={};for(const[n,o]of Object.entries(e))t.has(n)||(r[n]=o);return r},l=(n,t)=>{const r=s(n),o=r.tuples(),a=e(t),i=[];for(const e of o)a(e)&&i.push(e);return r.output(i)},f=(n,t)=>{const r=s(n),o=r.tuples(),a=e(t),i=[];for(const e of o)a(e)||i.push(e);return r.output(i)};function y(){return y=Object.assign?Object.assign.bind():function(e){for(var n=1;n<arguments.length;n++){var t=arguments[n];for(var r in t)({}).hasOwnProperty.call(t,r)&&(e[r]=t[r])}return e},y.apply(null,arguments)}const d=(e,n)=>{const t=s(e),r=t.tuples(),o=[];for(const e of r)o.push(y({},e,n));return t.output(o)},T=(e,n)=>{const t=s(e),r=t.tuples(),o=(e=>"function"==typeof e?e:n=>e[n]||n)(n),a=[];for(const e of r){const n=Object.keys(e).reduce((n,t)=>(n[o(t)]=e[t],n),{});a.push(n)}return t.output(a)},g=(e,n,t)=>{var r;const o=new Set(null!=(r=null==t?void 0:t.except)?r:[]);return T(e,e=>o.has(e)?e:`${n}${e}`)},m=(e,n,t)=>{var r;const o=new Set(null!=(r=null==t?void 0:t.except)?r:[]);return T(e,e=>o.has(e)?e:`${e}${n}`)},R=(e,n)=>{const t=s(e),r=t.tuples(),a=[];for(const e of r){const t=n.reduce((n,t)=>(t in e&&(n[t]=e[t]),n),{});a.push(t)}return t.output(o(a))},h=(e,n)=>{const t=s(e),r=t.tuples(),a=new Set(n),i=[];for(const e of r){const n=Object.keys(e).reduce((n,t)=>(a.has(t)||(n[t]=e[t]),n),{});i.push(n)}return t.output(o(i))},x=(e,n)=>{const t=s(e),r=t.tuples(),o=[];for(const e of r){const t=y({},e);for(const[r,o]of Object.entries(n))t[r]="function"==typeof o?o(e):e[o];o.push(t)}return t.output(o)},A=(e,n)=>{const t=s(e),o=s(n),a=new Set,i=[];for(const e of t.tuples()){const n=r(e);a.has(n)||(a.add(n),i.push(e))}for(const e of o.tuples()){const n=r(e);a.has(n)||(a.add(n),i.push(e))}return t.output(i)},k=(e,n)=>{const t=s(e),o=s(n),a=new Set;for(const e of o.tuples())a.add(r(e));const i=new Set,u=[];for(const e of t.tuples()){const n=r(e);a.has(n)||i.has(n)||(i.add(n),u.push(e))}return t.output(u)},w=(e,n)=>{const t=s(e),o=s(n),a=new Set;for(const e of o.tuples())a.add(r(e));const i=new Set,u=[];for(const e of t.tuples()){const n=r(e);a.has(n)&&!i.has(n)&&(i.add(n),u.push(e))}return t.output(u)},b=(e,n,t)=>{const r=s(e),o=s(n),a=[...r.tuples()],u=[...o.tuples()],c=i(t,a,u),l=new Set;for(const e of u)l.add(p(e,c,"right"));const f=[];for(const e of a)l.has(p(e,c,"left"))&&f.push(e);return r.output(f)},K=(e,n,t)=>{const r=s(e),o=s(n),a=[...r.tuples()],u=[...o.tuples()],c=i(t,a,u),l=new Set;for(const e of u)l.add(p(e,c,"right"));const f=[];for(const e of a)l.has(p(e,c,"left"))||f.push(e);return r.output(f)},O=(e,n,t)=>y({},e,c(n,t)),j=(e,n,t)=>{const r=s(e),o=s(n),a=[...r.tuples()],p=[...o.tuples()],c=i(t,a,p),l=[];for(const e of a)for(const n of p)u(e,n,c)&&l.push(O(e,n,c));return r.output(l)},E=(e,n,t)=>{const r=y({},e);for(const e of t)r[e]=n?n[e]:null;return r},v=(e,n,t)=>{const r=s(e),o=s(n),a=[...r.tuples()],p=[...o.tuples()],c=i(t,a,p),l=((e,n)=>{if(0===e.length)return[];const t=new Set(Object.values(n));return Object.keys(e[0]).filter(e=>!t.has(e))})(p,c),f=[];for(const e of a){let n=!1;for(const t of p)u(e,t,c)&&(f.push(E(e,t,l)),n=!0);n||f.push(E(e,null,l))}return r.output(f)},S=(e,n)=>{const t=s(e),r=s(n),a=[...t.tuples()],i=[...r.tuples()],u=[];for(const e of a)for(const n of i)u.push(y({},n,e));return t.output(o(u))},P=(e,t,r,o)=>{const a=s(e),p=s(t),l=[...a.tuples()],f=[...p.tuples()],d=i(o,l,f),T=[];for(const e of l){const t=[];for(const n of f)u(e,n,d)&&t.push(c(n,d));T.push(y({},e,{[r]:new n(t)}))}return a.output(T)},N=(e,n)=>n.map(n=>JSON.stringify(e[n])).join("|"),J=(e,n)=>n.reduce((n,t)=>(n[t]=e[t],n),{}),L=(e,n)=>{if("function"==typeof n)return n(e);const t="string"==typeof n?{op:n,attr:""}:n,{op:r,attr:o}=t;switch(r){case"count":return e.length;case"sum":return e.reduce((e,n)=>e+(Number(n[o])||0),0);case"min":{const n=e.map(e=>e[o]).filter(e=>null!=e);return n.length>0?Math.min(...n.map(Number)):null}case"max":{const n=e.map(e=>e[o]).filter(e=>null!=e);return n.length>0?Math.max(...n.map(Number)):null}case"avg":{const n=e.map(e=>Number(e[o])).filter(e=>!isNaN(e));return n.length>0?n.reduce((e,n)=>e+n,0)/n.length:null}case"collect":return e.map(e=>e[o]);default:throw new Error(`Unknown aggregator: ${r}`)}},F=(e,n,t)=>{const r=s(e),o=[...r.tuples()],a=new Map;for(const e of o){const t=N(e,n);a.has(t)||a.set(t,[]),a.get(t).push(e)}const i=[];for(const e of a.values()){const r=J(e[0],n);for(const[n,o]of Object.entries(t))r[n]=L(e,o);i.push(r)}return r.output(i)},B=(e,n)=>n.map(n=>JSON.stringify(e[n])).join("|"),$=(e,n)=>n.reduce((n,t)=>(n[t]=e[t],n),{}),_=(e,t,r)=>{const o=s(e),a=[...o.tuples()];if(0===a.length)return o.output([]);const i=Object.keys(a[0]),u=new Set(t),p=i.filter(e=>!u.has(e)),c=new Map;for(const e of a){const n=B(e,p);c.has(n)||c.set(n,{base:$(e,p),nested:[]}),c.get(n).nested.push($(e,t))}const l=[];for(const{base:e,nested:t}of c.values())l.push(y({},e,{[r]:new n(t)}));return o.output(l)},M=e=>{if(t(e))return e.toArray();if(Array.isArray(e))return e;throw new Error("Value is not a relation or array")},U=(e,n)=>{const t=s(e),r=[...t.tuples()],o=[];for(const e of r){const t=M(e[n]),r={};for(const[t,o]of Object.entries(e))t!==n&&(r[t]=o);for(const e of t)o.push(y({},r,e))}return t.output(o)},C=(e,n,t)=>{const r=s(e),o=r.tuples(),a=new Set(n),i=[];for(const e of o){const n={},r={};for(const[t,o]of Object.entries(e))a.has(t)?n[t]=o:r[t]=o;i.push(y({},r,{[t]:n}))}return r.output(i)},X=(e,n)=>{const t=s(e),r=t.tuples(),o=[];for(const e of r){const t=e[n];if("object"!=typeof t||null===t||Array.isArray(t))throw new Error(`Attribute '${n}' is not a tuple (object)`);const r={};for(const[t,o]of Object.entries(e))t!==n&&(r[t]=o);o.push(y({},r,t))}return t.output(o)},q=(e,n)=>{var t;const r=null!=(t=null==n?void 0:n.separator)?t:"_",o=s(e),a=o.tuples(),i=[];for(const e of a){const n={};for(const[t,o]of Object.entries(e)){const e=t.split(r);if(1===e.length)n[t]=o;else{var u;const[t,...s]=e;n[t]=null!=(u=n[t])?u:{},n[t][s.join(r)]=o}}i.push(n)}return o.output(i)},z=(e,n)=>{const t=s(e),r=t.tuples(),o=[];for(const e of r){const t={};for(const[r,o]of Object.entries(e))t[r]=D(o,r,n);o.push(t)}return t.output(o)},D=(e,n,t)=>{if("function"==typeof t)return t(e);if(Array.isArray(t))return t.reduce((e,n)=>n(e),e);{const r=t[n];return r?Array.isArray(r)?r.reduce((e,n)=>n(e),e):r(e):e}},H=(e,n)=>{const t=s(e),o=s(n),a=new Set;for(const e of t.tuples())a.add(r(e));const i=new Set;for(const e of o.tuples())i.add(r(e));if(a.size!==i.size)return!1;for(const e of a)if(!i.has(e))return!1;return!0},I=e=>{const n=s(e).tuples();let t;for(const e of n){if(t)return a("More than one tuple found");t=e}return t||a("Relation is empty")},W=(e,n,t)=>{const r=s(e).tuples(),o={};for(const e of r)o[`${e[t]}`]=e[n];return o},Y="\n/**\n * Type definitions for Bmg.js relational algebra library.\n *\n * This file defines all types needed for type-safe relational operations:\n * - Base types (AttrName, Tuple)\n * - Utility types for transformations (Renamed, Prefixed, Joined, etc.)\n * - The Relation interface with all operators\n * - Helper types for predicates, extensions, aggregators, etc.\n */\n\n// ============================================================================\n// Base Types\n// ============================================================================\n\n/** Attribute name in a tuple */\ntype AttrName = string\n\n/** A tuple is a record mapping attribute names to values */\ntype Tuple = Record<AttrName, unknown>\n\n// ============================================================================\n// Rename Types\n// ============================================================================\n\n/** Map from old attribute names to new attribute names */\ntype RenameMap<T> = { [K in keyof T]?: string };\n\n/** Transform tuple type by renaming keys according to RenameMap */\ntype Renamed<T, R extends RenameMap<T>> = {\n  [K in keyof T as K extends keyof R ? (R[K] extends string ? R[K] : K) : K]: T[K];\n};\n\n// ============================================================================\n// Prefix/Suffix Types\n// ============================================================================\n\n/** Prefix all keys except those in Except */\ntype Prefixed<T, P extends string, Except extends keyof T = never> = {\n  [K in keyof T as K extends Except ? K : `${P}${K & string}`]: T[K];\n};\n\n/** Suffix all keys except those in Except */\ntype Suffixed<T, S extends string, Except extends keyof T = never> = {\n  [K in keyof T as K extends Except ? K : `${K & string}${S}`]: T[K];\n};\n\n// ============================================================================\n// Join Types\n// ============================================================================\n\n/** Extract common keys between two tuple types */\ntype CommonKeys<L, R> = Extract<keyof L, keyof R>;\n\n/** Result of inner join: L & R with R's common keys removed */\ntype Joined<L, R> = L & Omit<R, CommonKeys<L, R>>;\n\n/** Result of left join: L & optional R attributes (common keys removed) */\ntype LeftJoined<L, R> = L & Partial<Omit<R, CommonKeys<L, R>>>;\n\n/**\n * Typed join keys for array form: keys must exist on BOTH operands.\n * Example: suppliers.join(parts, ['city']) - 'city' must be a key of both.\n */\ntype TypedJoinKeysArray<L, R> = (keyof L & keyof R & string)[];\n\n/**\n * Typed join keys for object form: maps left keys to right keys.\n * Example: suppliers.join(parts, { sid: 'supplier_id' })\n * - Left key (sid) must exist on L\n * - Right key (supplier_id) must exist on R\n */\ntype TypedJoinKeysObject<L, R> = { [K in keyof L & string]?: keyof R & string };\n\n// ============================================================================\n// Wrap/Unwrap Types\n// ============================================================================\n\n/** Result of wrap: remove wrapped attrs, add nested object */\ntype Wrapped<T, K extends keyof T, As extends string> =\n  Omit<T, K> & Record<As, Pick<T, K>>;\n\n/** Result of unwrap: remove object attr, spread its properties */\ntype Unwrapped<T, K extends keyof T> =\n  T[K] extends Record<string, unknown> ? Omit<T, K> & T[K] : Omit<T, K>;\n\n/** Result of ungroup: remove relation attr, flatten its tuple type */\ntype Ungrouped<T, K extends keyof T> =\n  T[K] extends Relation<infer N> ? Omit<T, K> & N : Omit<T, K>;\n\n// ============================================================================\n// Aggregator Types\n// ============================================================================\n\ntype AggregatorName = 'count' | 'sum' | 'min' | 'max' | 'avg' | 'collect'\ntype AggregatorSpec = { op: AggregatorName, attr: AttrName }\ntype AggregatorFunc = (tuples: Tuple[]) => unknown\ntype Aggregator = AggregatorName | AggregatorSpec | AggregatorFunc\ntype Aggregators = Record<AttrName, Aggregator>\n\n/** Infer result type from aggregator specification */\ntype AggregatorResult<A> =\n  A extends 'count' ? number :\n  A extends { op: 'count' } ? number :\n  A extends { op: 'sum' | 'avg' | 'min' | 'max' } ? number | null :\n  A extends { op: 'collect' } ? unknown[] :\n  A extends (tuples: Tuple[]) => infer R ? R :\n  unknown;\n\n/** Map aggregator definitions to their result types */\ntype AggregatorResults<Aggs extends Record<string, unknown>> = {\n  [K in keyof Aggs]: AggregatorResult<Aggs[K]>;\n};\n\n// ============================================================================\n// Predicate Types\n// ============================================================================\n\n/** Predicate function that receives a typed tuple */\ntype TypedPredicateFunc<T> = (t: T) => boolean\n\n/** Predicate: either a partial tuple for equality matching, or a function */\ntype TypedPredicate<T> = Partial<T> | TypedPredicateFunc<T>\n\n// Legacy predicate types (for backwards compatibility with standalone operators)\ntype PredicateFunc = ((t: Tuple) => any)\ntype Predicate = Tuple | PredicateFunc\n\n// ============================================================================\n// Extension Types\n// ============================================================================\n\n/** Extension function that receives a typed tuple */\ntype TypedExtensionFunc<T, R> = (tuple: T) => R\n\n/** Extension definition: function returning value, or attribute name to copy */\ntype TypedExtension<T, E extends Record<string, unknown>> = {\n  [K in keyof E]: TypedExtensionFunc<T, E[K]> | keyof T;\n}\n\ntype ExtensionFunc = (tuple: Tuple) => unknown\ntype Extension = Record<AttrName, ExtensionFunc | AttrName>\n\n// ============================================================================\n// Other Helper Types\n// ============================================================================\n\ninterface PrefixOptions {\n  except?: AttrName[]\n}\n\ninterface SuffixOptions {\n  except?: AttrName[]\n}\n\ninterface AutowrapOptions {\n  separator?: string\n}\n\ntype Renaming = RenamingObj | RenamingFunc\ntype RenamingFunc = (attr: AttrName) => AttrName\ntype RenamingObj = Record<AttrName, AttrName>\n\ntype JoinKeys = AttrName[] | Record<AttrName, AttrName>\n\ntype TransformFunc = (value: unknown) => unknown\ntype Transformation = TransformFunc | TransformFunc[] | Record<AttrName, TransformFunc | TransformFunc[]>\n\n// ============================================================================\n// Relation Interface\n// ============================================================================\n\n/**\n * Relation interface with generic type parameter for tuple type.\n * Default parameter `Tuple` ensures backwards compatibility.\n *\n * @typeParam T - The tuple type for this relation. Defaults to `Tuple` (Record<string, unknown>).\n *\n * @example\n * // Untyped usage (backwards compatible)\n * const r = Bmg([{ id: 1 }]);  // Relation<Tuple>\n *\n * @example\n * // Typed usage with full type safety\n * interface Person { id: number; name: string }\n * const r = Bmg<Person>([{ id: 1, name: 'Alice' }]);\n * r.project(['id']);  // Relation<{ id: number }>\n */\ninterface Relation<T = Tuple> {\n  // === Type-preserving operators ===\n\n  restrict(p: TypedPredicate<T>): Relation<T>\n  where(p: TypedPredicate<T>): Relation<T>\n  exclude(p: TypedPredicate<T>): Relation<T>\n\n  // === Projection operators ===\n\n  project<K extends keyof T>(attrs: K[]): Relation<Pick<T, K>>\n  allbut<K extends keyof T>(attrs: K[]): Relation<Omit<T, K>>\n\n  // === Extension operators ===\n\n  extend<E extends Record<string, unknown>>(e: TypedExtension<T, E>): Relation<T & E>\n  constants<C extends Tuple>(consts: C): Relation<T & C>\n\n  // === Rename operators ===\n\n  rename<R extends RenameMap<T>>(r: R): Relation<Renamed<T, R>>\n  prefix<P extends string, Ex extends keyof T = never>(pfx: P, options?: { except?: Ex[] }): Relation<Prefixed<T, P, Ex>>\n  suffix<S extends string, Ex extends keyof T = never>(sfx: S, options?: { except?: Ex[] }): Relation<Suffixed<T, S, Ex>>\n\n  // === Set operators (require same type) ===\n\n  union(right: RelationOperand<T>): Relation<T>\n  minus(right: RelationOperand<T>): Relation<T>\n  intersect(right: RelationOperand<T>): Relation<T>\n\n  // === Semi-join operators (preserve left type) ===\n\n  matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T>\n  not_matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T>\n\n  // === Join operators ===\n\n  join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<Joined<T, R>>\n  left_join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<LeftJoined<T, R>>\n  cross_product<R>(right: RelationOperand<R>): Relation<T & R>\n  cross_join<R>(right: RelationOperand<R>): Relation<T & R>\n\n  // === Nesting operators ===\n\n  image<R, As extends string>(right: RelationOperand<R>, as: As, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T & Record<As, Relation<Omit<R, keyof T & keyof R>>>>\n  group<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Omit<T, K> & Record<As, Relation<Pick<T, K>>>>\n  ungroup<K extends keyof T>(attr: K): Relation<Ungrouped<T, K>>\n  wrap<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Wrapped<T, K, As>>\n  unwrap<K extends keyof T>(attr: K): Relation<Unwrapped<T, K>>\n\n  // === Aggregation ===\n\n  summarize<By extends keyof T, Aggs extends Aggregators>(by: By[], aggs: Aggs): Relation<Pick<T, By> & AggregatorResults<Aggs>>\n\n  // === Transform ===\n\n  transform(t: Transformation): Relation<T>\n\n  // === Dynamic (loses type precision) ===\n\n  autowrap(options?: AutowrapOptions): Relation<Tuple>\n\n  // === Non-relational ===\n\n  one(): T\n  yByX<Y extends keyof T, X extends keyof T>(y: Y, x: X): Record<T[X] & PropertyKey, T[Y]>\n  toArray(): T[]\n  isEqual(right: any): boolean\n}\n\n// ============================================================================\n// Operands\n// ============================================================================\n\ntype RelationOperand<T = Tuple> = Relation<T> | T[]\n\ninterface OperationalOperand<T = Tuple> {\n  tuples(): Iterable<T>\n  output(tuples: T[]): RelationOperand<T>\n}\n\n// ============================================================================\n// Bmg Function Declaration\n// ============================================================================\n\n/** Create a relation from an array of tuples */\ndeclare function Bmg<T>(tuples: T[]): Relation<T>\ndeclare namespace Bmg {\n  function isRelation(op: unknown): boolean\n}\n";function V(e){return new n(e)}V.isRelation=t;export{V as Bmg,Y as LIB_DEFINITIONS,h as allbut,q as autowrap,d as constants,S as cross_join,S as cross_product,f as exclude,x as extend,_ as group,P as image,w as intersect,H as isEqual,t as isRelation,j as join,v as left_join,b as matching,k as minus,K as not_matching,I as one,g as prefix,R as project,T as rename,l as restrict,m as suffix,F as summarize,z as transform,U as ungroup,A as union,X as unwrap,l as where,C as wrap,W as yByX};
+const e=e=>{if("function"==typeof e)return e;{const n=e;return e=>Object.keys(n).every(t=>e[t]===n[t])}},n=e=>null!=e&&e.constructor===p,t=e=>null!==e&&"object"==typeof e&&!Array.isArray(e),r=(e,n)=>null===e?null!=n?n:0:null===n||e>n?e:n;class s{constructor(e,n){this.value=void 0,this.renderer=void 0,this._textRendering=null,this._minWidth=null,this.renderer=e,this.value=n}get minWidth(){return null===this._minWidth&&(this._minWidth=this.renderingLines().reduce((e,n)=>r(e,n.length),0)),this._minWidth}renderingLines(e){return void 0===e?this.textRendering.split("\n"):"number"==typeof this.value?this.renderingLines().map(n=>n.padStart(e)):this.renderingLines().map(n=>n.padEnd(e))}get textRendering(){return null===this._textRendering&&(this._textRendering=this.computeTextRendering()),this._textRendering}computeTextRendering(){const e=this.value;if(null===e)return"[null]";if(void 0===e)return"[undefined]";if("symbol"==typeof e)return e.toString();if("number"==typeof e){var r;if(Number.isInteger(e))return String(e);const n=null!=(r=this.renderer.options.floatPrecision)?r:3;return e.toFixed(n)}return n(s=e)||Array.isArray(s)&&s.every(t)?this.renderer.render(e,""):Array.isArray(e)?this.arrayRendering(e):e instanceof Date?e.toISOString():"object"==typeof e?JSON.stringify(e):String(e);var s}arrayRendering(e){if(e.length>0&&t(e[0]))return this.renderer.render(e,"");if(0===e.length)return"[]";const n=e.map(e=>new s(this.renderer,e).textRendering);return n.reduce((e,n)=>e+n.length,0)<20?"["+n.join(", ")+"]":"["+n.join(",\n ")+"]"}}class o{constructor(e,n){this.cells=void 0,this.cells=n.map(n=>new s(e,n))}minWidths(){return this.cells.map(e=>e.minWidth)}renderingLines(e){let n=0;const t=this.cells.map((t,s)=>{const o=t.renderingLines(e[s]);return n=r(n,o.length),o}),s=[];for(let r=0;r<n;r++){const n=t.map((n,t)=>{var s;return null!=(s=n[r])?s:" ".repeat(e[t])}).join(" | ");s.push("| "+n+" |")}return 0===s.length?["|  |"]:s}}class i{constructor(e,n,t){this.renderer=void 0,this.header=void 0,this.rows=void 0,this._sizes=null,this._sep=null,this.renderer=e,this.header=new o(e,t),this.rows=n.map(n=>new o(e,n))}get sizes(){if(null===this._sizes){const e=this.header.minWidths();this._sizes=this.rows.reduce((e,n)=>{const t=n.minWidths();return e.map((e,n)=>{var s;return r(e,null!=(s=t[n])?s:0)})},e)}return this._sizes}get sep(){return null===this._sep&&(this._sep="+-"+this.sizes.map(e=>"-".repeat(e)).join("-+-")+"-+"),this._sep}*eachLine(){const e=this.renderer.options.trimAt;if(void 0!==e)for(const n of this.eachLineRaw())yield n.substring(0,e);else yield*this.eachLineRaw()}*eachLineRaw(){yield this.sep,yield this.header.renderingLines(this.sizes)[0],yield this.sep;for(const e of this.rows)for(const n of e.renderingLines(this.sizes))yield n;yield this.sep}*[Symbol.iterator](){for(const e of this.eachLine())yield e.trimEnd()+"\n"}toString(){let e="";for(const n of this)e+=n;return e}}class a{constructor(e={}){this.options=void 0,this.options=e}render(e,n=""){for(const t of this.eachLine(e))n+=t;return n}*eachLine(e){let r;r=t(e)&&!n(e)?[e]:n(e)?e.toArray():e;const s=r.reduce((e,n)=>{for(const t of Object.keys(n))e.includes(t)||e.push(t);return e},[]),o=r.map(e=>s.map(n=>e[n])),a=new i(this,o,s);yield*a}}const u=(e,n={})=>new a(n).render(e);class p{constructor(e){this.tuples=void 0,this.tuples=e,this.tuples=e}restrict(e){return T(this,e)}where(e){return T(this,e)}exclude(e){return R(this,e)}project(e){return O(this,e)}allbut(e){return K(this,e)}extend(e){return j(this,e)}constants(e){return A(this,e)}rename(e){return w(this,e)}prefix(e,n){return b(this,e,n)}suffix(e,n){return k(this,e,n)}union(e){return v(this,e)}minus(e){return S(this,e)}intersect(e){return E(this,e)}matching(e,n){return P(this,e,n)}not_matching(e,n){return N(this,e,n)}join(e,n){return _(this,e,n)}left_join(e,n){return F(this,e,n)}cross_product(e){return B(this,e)}cross_join(e){return B(this,e)}image(e,n,t){return z(this,e,n,t)}group(e,n){return I(this,e,n)}ungroup(e){return q(this,e)}wrap(e,n){return H(this,e,n)}unwrap(e){return Y(this,e)}summarize(e,n){return U(this,e,n)}transform(e){return G(this,e)}autowrap(e){return V(this,e)}one(){return ee(this)}toArray(){return this.tuples}yByX(e,n){return ne(this,e,n)}isEqual(e){return Z(this,e)}toText(e){return u(this,e)}}const c=e=>{const t=Object.entries(e).map(([e,t])=>{return[e,(r=t,n(r)?r.toArray().map(e=>c(e)).sort():r)];var r});return JSON.stringify(t.sort(([e],[n])=>e.localeCompare(n)))},l=e=>{const n=new Set,t=[];for(const r of e){const e=c(r);n.has(e)||(n.add(e),t.push(r))}return t},f=e=>{if(Array.isArray(e))return{tuples:()=>e,output:e=>e};if(n(e))return{tuples:()=>e.toArray(),output:e=>new p(e)};throw`Unable to iterate ${e}`},d=e=>{throw e},y=(e,n,t)=>e?Array.isArray(e)?e.reduce((e,n)=>(e[n]=n,e),{}):e:((e,n)=>{if(0===e.length||0===n.length)return[];const t=new Set(Object.keys(e[0]));return Object.keys(n[0]).filter(e=>t.has(e))})(n,t).reduce((e,n)=>(e[n]=n,e),{}),h=(e,n,t)=>{for(const[r,s]of Object.entries(t))if(e[r]!==n[s])return!1;return!0},g=(e,n,t)=>("left"===t?Object.keys(n):Object.values(n)).map(n=>JSON.stringify(e[n])).join("|"),m=(e,n)=>{const t=new Set(Object.values(n)),r={};for(const[n,s]of Object.entries(e))t.has(n)||(r[n]=s);return r},T=(n,t)=>{const r=f(n),s=r.tuples(),o=e(t),i=[];for(const e of s)o(e)&&i.push(e);return r.output(i)},R=(n,t)=>{const r=f(n),s=r.tuples(),o=e(t),i=[];for(const e of s)o(e)||i.push(e);return r.output(i)};function x(){return x=Object.assign?Object.assign.bind():function(e){for(var n=1;n<arguments.length;n++){var t=arguments[n];for(var r in t)({}).hasOwnProperty.call(t,r)&&(e[r]=t[r])}return e},x.apply(null,arguments)}const A=(e,n)=>{const t=f(e),r=t.tuples(),s=[];for(const e of r)s.push(x({},e,n));return t.output(s)},w=(e,n)=>{const t=f(e),r=t.tuples(),s=(e=>"function"==typeof e?e:n=>e[n]||n)(n),o=[];for(const e of r){const n=Object.keys(e).reduce((n,t)=>(n[s(t)]=e[t],n),{});o.push(n)}return t.output(o)},b=(e,n,t)=>{var r;const s=new Set(null!=(r=null==t?void 0:t.except)?r:[]);return w(e,e=>s.has(e)?e:`${n}${e}`)},k=(e,n,t)=>{var r;const s=new Set(null!=(r=null==t?void 0:t.except)?r:[]);return w(e,e=>s.has(e)?e:`${e}${n}`)},O=(e,n)=>{const t=f(e),r=t.tuples(),s=[];for(const e of r){const t=n.reduce((n,t)=>(t in e&&(n[t]=e[t]),n),{});s.push(t)}return t.output(l(s))},K=(e,n)=>{const t=f(e),r=t.tuples(),s=new Set(n),o=[];for(const e of r){const n=Object.keys(e).reduce((n,t)=>(s.has(t)||(n[t]=e[t]),n),{});o.push(n)}return t.output(l(o))},j=(e,n)=>{const t=f(e),r=t.tuples(),s=[];for(const e of r){const t=x({},e);for(const[r,s]of Object.entries(n))t[r]="function"==typeof s?s(e):e[s];s.push(t)}return t.output(s)},v=(e,n)=>{const t=f(e),r=f(n),s=new Set,o=[];for(const e of t.tuples()){const n=c(e);s.has(n)||(s.add(n),o.push(e))}for(const e of r.tuples()){const n=c(e);s.has(n)||(s.add(n),o.push(e))}return t.output(o)},S=(e,n)=>{const t=f(e),r=f(n),s=new Set;for(const e of r.tuples())s.add(c(e));const o=new Set,i=[];for(const e of t.tuples()){const n=c(e);s.has(n)||o.has(n)||(o.add(n),i.push(e))}return t.output(i)},E=(e,n)=>{const t=f(e),r=f(n),s=new Set;for(const e of r.tuples())s.add(c(e));const o=new Set,i=[];for(const e of t.tuples()){const n=c(e);s.has(n)&&!o.has(n)&&(o.add(n),i.push(e))}return t.output(i)},P=(e,n,t)=>{const r=f(e),s=f(n),o=[...r.tuples()],i=[...s.tuples()],a=y(t,o,i),u=new Set;for(const e of i)u.add(g(e,a,"right"));const p=[];for(const e of o)u.has(g(e,a,"left"))&&p.push(e);return r.output(p)},N=(e,n,t)=>{const r=f(e),s=f(n),o=[...r.tuples()],i=[...s.tuples()],a=y(t,o,i),u=new Set;for(const e of i)u.add(g(e,a,"right"));const p=[];for(const e of o)u.has(g(e,a,"left"))||p.push(e);return r.output(p)},L=(e,n,t)=>x({},e,m(n,t)),_=(e,n,t)=>{const r=f(e),s=f(n),o=[...r.tuples()],i=[...s.tuples()],a=y(t,o,i),u=[];for(const e of o)for(const n of i)h(e,n,a)&&u.push(L(e,n,a));return r.output(u)},J=(e,n,t)=>{const r=x({},e);for(const e of t)r[e]=n?n[e]:null;return r},F=(e,n,t)=>{const r=f(e),s=f(n),o=[...r.tuples()],i=[...s.tuples()],a=y(t,o,i),u=((e,n)=>{if(0===e.length)return[];const t=new Set(Object.values(n));return Object.keys(e[0]).filter(e=>!t.has(e))})(i,a),p=[];for(const e of o){let n=!1;for(const t of i)h(e,t,a)&&(p.push(J(e,t,u)),n=!0);n||p.push(J(e,null,u))}return r.output(p)},B=(e,n)=>{const t=f(e),r=f(n),s=[...t.tuples()],o=[...r.tuples()],i=[];for(const e of s)for(const n of o)i.push(x({},n,e));return t.output(l(i))},z=(e,n,t,r)=>{const s=f(e),o=f(n),i=[...s.tuples()],a=[...o.tuples()],u=y(r,i,a),c=[];for(const e of i){const n=[];for(const t of a)h(e,t,u)&&n.push(m(t,u));c.push(x({},e,{[t]:new p(n)}))}return s.output(c)},M=(e,n)=>n.map(n=>JSON.stringify(e[n])).join("|"),W=(e,n)=>n.reduce((n,t)=>(n[t]=e[t],n),{}),$=(e,n)=>{if("function"==typeof n)return n(e);const t="string"==typeof n?{op:n,attr:""}:n,{op:r,attr:s}=t;switch(r){case"count":return e.length;case"sum":return e.reduce((e,n)=>e+(Number(n[s])||0),0);case"min":{const n=e.map(e=>e[s]).filter(e=>null!=e);return n.length>0?Math.min(...n.map(Number)):null}case"max":{const n=e.map(e=>e[s]).filter(e=>null!=e);return n.length>0?Math.max(...n.map(Number)):null}case"avg":{const n=e.map(e=>Number(e[s])).filter(e=>!isNaN(e));return n.length>0?n.reduce((e,n)=>e+n,0)/n.length:null}case"collect":return e.map(e=>e[s]);default:throw new Error(`Unknown aggregator: ${r}`)}},U=(e,n,t)=>{const r=f(e),s=[...r.tuples()],o=new Map;for(const e of s){const t=M(e,n);o.has(t)||o.set(t,[]),o.get(t).push(e)}const i=[];for(const e of o.values()){const r=W(e[0],n);for(const[n,s]of Object.entries(t))r[n]=$(e,s);i.push(r)}return r.output(i)},C=(e,n)=>n.map(n=>JSON.stringify(e[n])).join("|"),D=(e,n)=>n.reduce((n,t)=>(n[t]=e[t],n),{}),I=(e,n,t)=>{const r=f(e),s=[...r.tuples()];if(0===s.length)return r.output([]);const o=Object.keys(s[0]),i=new Set(n),a=o.filter(e=>!i.has(e)),u=new Map;for(const e of s){const t=C(e,a);u.has(t)||u.set(t,{base:D(e,a),nested:[]}),u.get(t).nested.push(D(e,n))}const c=[];for(const{base:e,nested:n}of u.values())c.push(x({},e,{[t]:new p(n)}));return r.output(c)},X=e=>{if(n(e))return e.toArray();if(Array.isArray(e))return e;throw new Error("Value is not a relation or array")},q=(e,n)=>{const t=f(e),r=[...t.tuples()],s=[];for(const e of r){const t=X(e[n]),r={};for(const[t,s]of Object.entries(e))t!==n&&(r[t]=s);for(const e of t)s.push(x({},r,e))}return t.output(s)},H=(e,n,t)=>{const r=f(e),s=r.tuples(),o=new Set(n),i=[];for(const e of s){const n={},r={};for(const[t,s]of Object.entries(e))o.has(t)?n[t]=s:r[t]=s;i.push(x({},r,{[t]:n}))}return r.output(i)},Y=(e,n)=>{const t=f(e),r=t.tuples(),s=[];for(const e of r){const t=e[n];if("object"!=typeof t||null===t||Array.isArray(t))throw new Error(`Attribute '${n}' is not a tuple (object)`);const r={};for(const[t,s]of Object.entries(e))t!==n&&(r[t]=s);s.push(x({},r,t))}return t.output(s)},V=(e,n)=>{var t;const r=null!=(t=null==n?void 0:n.separator)?t:"_",s=f(e),o=s.tuples(),i=[];for(const e of o){const n={};for(const[t,s]of Object.entries(e)){const e=t.split(r);if(1===e.length)n[t]=s;else{var a;const[t,...o]=e;n[t]=null!=(a=n[t])?a:{},n[t][o.join(r)]=s}}i.push(n)}return s.output(i)},G=(e,n)=>{const t=f(e),r=t.tuples(),s=[];for(const e of r){const t={};for(const[r,s]of Object.entries(e))t[r]=Q(s,r,n);s.push(t)}return t.output(s)},Q=(e,n,t)=>{if("function"==typeof t)return t(e);if(Array.isArray(t))return t.reduce((e,n)=>n(e),e);{const r=t[n];return r?Array.isArray(r)?r.reduce((e,n)=>n(e),e):r(e):e}},Z=(e,n)=>{const t=f(e),r=f(n),s=new Set;for(const e of t.tuples())s.add(c(e));const o=new Set;for(const e of r.tuples())o.add(c(e));if(s.size!==o.size)return!1;for(const e of s)if(!o.has(e))return!1;return!0},ee=e=>{const n=f(e).tuples();let t;for(const e of n){if(t)return d("More than one tuple found");t=e}return t||d("Relation is empty")},ne=(e,n,t)=>{const r=f(e).tuples(),s={};for(const e of r)s[`${e[t]}`]=e[n];return s},te="\n/**\n * Type definitions for Bmg.js relational algebra library.\n *\n * This file defines all types needed for type-safe relational operations:\n * - Base types (AttrName, Tuple)\n * - Utility types for transformations (Renamed, Prefixed, Joined, etc.)\n * - The Relation interface with all operators\n * - Helper types for predicates, extensions, aggregators, etc.\n */\n\n// ============================================================================\n// Base Types\n// ============================================================================\n\n/** Attribute name in a tuple */\ntype AttrName = string\n\n/** A tuple is a record mapping attribute names to values */\ntype Tuple = Record<AttrName, unknown>\n\n// ============================================================================\n// Rename Types\n// ============================================================================\n\n/** Map from old attribute names to new attribute names */\ntype RenameMap<T> = { [K in keyof T]?: string };\n\n/** Transform tuple type by renaming keys according to RenameMap */\ntype Renamed<T, R extends RenameMap<T>> = {\n  [K in keyof T as K extends keyof R ? (R[K] extends string ? R[K] : K) : K]: T[K];\n};\n\n// ============================================================================\n// Prefix/Suffix Types\n// ============================================================================\n\n/** Prefix all keys except those in Except */\ntype Prefixed<T, P extends string, Except extends keyof T = never> = {\n  [K in keyof T as K extends Except ? K : `${P}${K & string}`]: T[K];\n};\n\n/** Suffix all keys except those in Except */\ntype Suffixed<T, S extends string, Except extends keyof T = never> = {\n  [K in keyof T as K extends Except ? K : `${K & string}${S}`]: T[K];\n};\n\n// ============================================================================\n// Join Types\n// ============================================================================\n\n/** Extract common keys between two tuple types */\ntype CommonKeys<L, R> = Extract<keyof L, keyof R>;\n\n/** Result of inner join: L & R with R's common keys removed */\ntype Joined<L, R> = L & Omit<R, CommonKeys<L, R>>;\n\n/** Result of left join: L & optional R attributes (common keys removed) */\ntype LeftJoined<L, R> = L & Partial<Omit<R, CommonKeys<L, R>>>;\n\n/**\n * Typed join keys for array form: keys must exist on BOTH operands.\n * Example: suppliers.join(parts, ['city']) - 'city' must be a key of both.\n */\ntype TypedJoinKeysArray<L, R> = (keyof L & keyof R & string)[];\n\n/**\n * Typed join keys for object form: maps left keys to right keys.\n * Example: suppliers.join(parts, { sid: 'supplier_id' })\n * - Left key (sid) must exist on L\n * - Right key (supplier_id) must exist on R\n */\ntype TypedJoinKeysObject<L, R> = { [K in keyof L & string]?: keyof R & string };\n\n// ============================================================================\n// Wrap/Unwrap Types\n// ============================================================================\n\n/** Result of wrap: remove wrapped attrs, add nested object */\ntype Wrapped<T, K extends keyof T, As extends string> =\n  Omit<T, K> & Record<As, Pick<T, K>>;\n\n/** Result of unwrap: remove object attr, spread its properties */\ntype Unwrapped<T, K extends keyof T> =\n  T[K] extends Record<string, unknown> ? Omit<T, K> & T[K] : Omit<T, K>;\n\n/** Result of ungroup: remove relation attr, flatten its tuple type */\ntype Ungrouped<T, K extends keyof T> =\n  T[K] extends Relation<infer N> ? Omit<T, K> & N : Omit<T, K>;\n\n// ============================================================================\n// Aggregator Types\n// ============================================================================\n\ntype AggregatorName = 'count' | 'sum' | 'min' | 'max' | 'avg' | 'collect'\ntype AggregatorSpec = { op: AggregatorName, attr: AttrName }\ntype AggregatorFunc = (tuples: Tuple[]) => unknown\ntype Aggregator = AggregatorName | AggregatorSpec | AggregatorFunc\ntype Aggregators = Record<AttrName, Aggregator>\n\n/** Infer result type from aggregator specification */\ntype AggregatorResult<A> =\n  A extends 'count' ? number :\n  A extends { op: 'count' } ? number :\n  A extends { op: 'sum' | 'avg' | 'min' | 'max' } ? number | null :\n  A extends { op: 'collect' } ? unknown[] :\n  A extends (tuples: Tuple[]) => infer R ? R :\n  unknown;\n\n/** Map aggregator definitions to their result types */\ntype AggregatorResults<Aggs extends Record<string, unknown>> = {\n  [K in keyof Aggs]: AggregatorResult<Aggs[K]>;\n};\n\n// ============================================================================\n// Predicate Types\n// ============================================================================\n\n/** Predicate function that receives a typed tuple */\ntype TypedPredicateFunc<T> = (t: T) => boolean\n\n/** Predicate: either a partial tuple for equality matching, or a function */\ntype TypedPredicate<T> = Partial<T> | TypedPredicateFunc<T>\n\n// Legacy predicate types (for backwards compatibility with standalone operators)\ntype PredicateFunc = ((t: Tuple) => any)\ntype Predicate = Tuple | PredicateFunc\n\n// ============================================================================\n// Extension Types\n// ============================================================================\n\n/** Extension function that receives a typed tuple */\ntype TypedExtensionFunc<T, R> = (tuple: T) => R\n\n/** Extension definition: function returning value, or attribute name to copy */\ntype TypedExtension<T, E extends Record<string, unknown>> = {\n  [K in keyof E]: TypedExtensionFunc<T, E[K]> | keyof T;\n}\n\ntype ExtensionFunc = (tuple: Tuple) => unknown\ntype Extension = Record<AttrName, ExtensionFunc | AttrName>\n\n// ============================================================================\n// Other Helper Types\n// ============================================================================\n\ninterface PrefixOptions {\n  except?: AttrName[]\n}\n\ninterface TextOptions {\n  /** Precision for floating point numbers (default: 3) */\n  floatPrecision?: number;\n  /** Maximum width to trim output at */\n  trimAt?: number;\n}\n\ninterface SuffixOptions {\n  except?: AttrName[]\n}\n\ninterface AutowrapOptions {\n  separator?: string\n}\n\ntype Renaming = RenamingObj | RenamingFunc\ntype RenamingFunc = (attr: AttrName) => AttrName\ntype RenamingObj = Record<AttrName, AttrName>\n\ntype JoinKeys = AttrName[] | Record<AttrName, AttrName>\n\ntype TransformFunc = (value: unknown) => unknown\ntype Transformation = TransformFunc | TransformFunc[] | Record<AttrName, TransformFunc | TransformFunc[]>\n\n// ============================================================================\n// Relation Interface\n// ============================================================================\n\n/**\n * Relation interface with generic type parameter for tuple type.\n * Default parameter `Tuple` ensures backwards compatibility.\n *\n * @typeParam T - The tuple type for this relation. Defaults to `Tuple` (Record<string, unknown>).\n *\n * @example\n * // Untyped usage (backwards compatible)\n * const r = Bmg([{ id: 1 }]);  // Relation<Tuple>\n *\n * @example\n * // Typed usage with full type safety\n * interface Person { id: number; name: string }\n * const r = Bmg<Person>([{ id: 1, name: 'Alice' }]);\n * r.project(['id']);  // Relation<{ id: number }>\n */\ninterface Relation<T = Tuple> {\n  // === Type-preserving operators ===\n\n  restrict(p: TypedPredicate<T>): Relation<T>\n  where(p: TypedPredicate<T>): Relation<T>\n  exclude(p: TypedPredicate<T>): Relation<T>\n\n  // === Projection operators ===\n\n  project<K extends keyof T>(attrs: K[]): Relation<Pick<T, K>>\n  allbut<K extends keyof T>(attrs: K[]): Relation<Omit<T, K>>\n\n  // === Extension operators ===\n\n  extend<E extends Record<string, unknown>>(e: TypedExtension<T, E>): Relation<T & E>\n  constants<C extends Tuple>(consts: C): Relation<T & C>\n\n  // === Rename operators ===\n\n  rename<R extends RenameMap<T>>(r: R): Relation<Renamed<T, R>>\n  prefix<P extends string, Ex extends keyof T = never>(pfx: P, options?: { except?: Ex[] }): Relation<Prefixed<T, P, Ex>>\n  suffix<S extends string, Ex extends keyof T = never>(sfx: S, options?: { except?: Ex[] }): Relation<Suffixed<T, S, Ex>>\n\n  // === Set operators (require same type) ===\n\n  union(right: RelationOperand<T>): Relation<T>\n  minus(right: RelationOperand<T>): Relation<T>\n  intersect(right: RelationOperand<T>): Relation<T>\n\n  // === Semi-join operators (preserve left type) ===\n\n  matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T>\n  not_matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T>\n\n  // === Join operators ===\n\n  join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<Joined<T, R>>\n  left_join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<LeftJoined<T, R>>\n  cross_product<R>(right: RelationOperand<R>): Relation<T & R>\n  cross_join<R>(right: RelationOperand<R>): Relation<T & R>\n\n  // === Nesting operators ===\n\n  image<R, As extends string>(right: RelationOperand<R>, as: As, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T & Record<As, Relation<Omit<R, keyof T & keyof R>>>>\n  group<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Omit<T, K> & Record<As, Relation<Pick<T, K>>>>\n  ungroup<K extends keyof T>(attr: K): Relation<Ungrouped<T, K>>\n  wrap<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Wrapped<T, K, As>>\n  unwrap<K extends keyof T>(attr: K): Relation<Unwrapped<T, K>>\n\n  // === Aggregation ===\n\n  summarize<By extends keyof T, Aggs extends Aggregators>(by: By[], aggs: Aggs): Relation<Pick<T, By> & AggregatorResults<Aggs>>\n\n  // === Transform ===\n\n  transform(t: Transformation): Relation<T>\n\n  // === Dynamic (loses type precision) ===\n\n  autowrap(options?: AutowrapOptions): Relation<Tuple>\n\n  // === Non-relational ===\n\n  one(): T\n  yByX<Y extends keyof T, X extends keyof T>(y: Y, x: X): Record<T[X] & PropertyKey, T[Y]>\n  toArray(): T[]\n  isEqual(right: any): boolean\n\n  // === Display ===\n\n  toText(options?: TextOptions): string\n}\n\n// ============================================================================\n// Operands\n// ============================================================================\n\ntype RelationOperand<T = Tuple> = Relation<T> | T[]\n\ninterface OperationalOperand<T = Tuple> {\n  tuples(): Iterable<T>\n  output(tuples: T[]): RelationOperand<T>\n}\n\n// ============================================================================\n// Bmg Function Declaration\n// ============================================================================\n\n/** Create a relation from an array of tuples */\ndeclare function Bmg<T>(tuples: T[]): Relation<T>\ndeclare namespace Bmg {\n  function isRelation(op: unknown): boolean\n}\n";function re(e){return new p(e)}re.isRelation=n;const se=new p([{}]),oe=new p([]);export{re as Bmg,se as DEE,oe as DUM,te as LIB_DEFINITIONS,K as allbut,V as autowrap,A as constants,B as cross_join,B as cross_product,R as exclude,j as extend,I as group,z as image,E as intersect,Z as isEqual,n as isRelation,_ as join,F as left_join,P as matching,S as minus,N as not_matching,ee as one,b as prefix,O as project,w as rename,T as restrict,k as suffix,U as summarize,u as toText,G as transform,q as ungroup,v as union,Y as unwrap,T as where,H as wrap,ne as yByX};
 //# sourceMappingURL=bmg.modern.js.map