@bluefly/openstandardagents 0.4.6 → 0.4.9

package/node_modules/ajv/lib/compile/codegen/index.ts

@@ -1,852 +0,0 @@
-import type {ScopeValueSets, NameValue, ValueScope, ValueScopeName} from "./scope"
-import {_, nil, _Code, Code, Name, UsedNames, CodeItem, addCodeArg, _CodeOrName} from "./code"
-import {Scope, varKinds} from "./scope"
-
-export {_, str, strConcat, nil, getProperty, stringify, regexpCode, Name, Code} from "./code"
-export {Scope, ScopeStore, ValueScope, ValueScopeName, ScopeValueSets, varKinds} from "./scope"
-
-// type for expressions that can be safely inserted in code without quotes
-export type SafeExpr = Code | number | boolean | null
-
-// type that is either Code of function that adds code to CodeGen instance using its methods
-export type Block = Code | (() => void)
-
-export const operators = {
-  GT: new _Code(">"),
-  GTE: new _Code(">="),
-  LT: new _Code("<"),
-  LTE: new _Code("<="),
-  EQ: new _Code("==="),
-  NEQ: new _Code("!=="),
-  NOT: new _Code("!"),
-  OR: new _Code("||"),
-  AND: new _Code("&&"),
-  ADD: new _Code("+"),
-}
-
-abstract class Node {
-  abstract readonly names: UsedNames
-
-  optimizeNodes(): this | ChildNode | ChildNode[] | undefined {
-    return this
-  }
-
-  optimizeNames(_names: UsedNames, _constants: Constants): this | undefined {
-    return this
-  }
-
-  // get count(): number {
-  //   return 1
-  // }
-}
-
-class Def extends Node {
-  constructor(
-    private readonly varKind: Name,
-    private readonly name: Name,
-    private rhs?: SafeExpr
-  ) {
-    super()
-  }
-
-  render({es5, _n}: CGOptions): string {
-    const varKind = es5 ? varKinds.var : this.varKind
-    const rhs = this.rhs === undefined ? "" : ` = ${this.rhs}`
-    return `${varKind} ${this.name}${rhs};` + _n
-  }
-
-  optimizeNames(names: UsedNames, constants: Constants): this | undefined {
-    if (!names[this.name.str]) return
-    if (this.rhs) this.rhs = optimizeExpr(this.rhs, names, constants)
-    return this
-  }
-
-  get names(): UsedNames {
-    return this.rhs instanceof _CodeOrName ? this.rhs.names : {}
-  }
-}
-
-class Assign extends Node {
-  constructor(
-    readonly lhs: Code,
-    public rhs: SafeExpr,
-    private readonly sideEffects?: boolean
-  ) {
-    super()
-  }
-
-  render({_n}: CGOptions): string {
-    return `${this.lhs} = ${this.rhs};` + _n
-  }
-
-  optimizeNames(names: UsedNames, constants: Constants): this | undefined {
-    if (this.lhs instanceof Name && !names[this.lhs.str] && !this.sideEffects) return
-    this.rhs = optimizeExpr(this.rhs, names, constants)
-    return this
-  }
-
-  get names(): UsedNames {
-    const names = this.lhs instanceof Name ? {} : {...this.lhs.names}
-    return addExprNames(names, this.rhs)
-  }
-}
-
-class AssignOp extends Assign {
-  constructor(
-    lhs: Code,
-    private readonly op: Code,
-    rhs: SafeExpr,
-    sideEffects?: boolean
-  ) {
-    super(lhs, rhs, sideEffects)
-  }
-
-  render({_n}: CGOptions): string {
-    return `${this.lhs} ${this.op}= ${this.rhs};` + _n
-  }
-}
-
-class Label extends Node {
-  readonly names: UsedNames = {}
-  constructor(readonly label: Name) {
-    super()
-  }
-
-  render({_n}: CGOptions): string {
-    return `${this.label}:` + _n
-  }
-}
-
-class Break extends Node {
-  readonly names: UsedNames = {}
-  constructor(readonly label?: Code) {
-    super()
-  }
-
-  render({_n}: CGOptions): string {
-    const label = this.label ? ` ${this.label}` : ""
-    return `break${label};` + _n
-  }
-}
-
-class Throw extends Node {
-  constructor(readonly error: Code) {
-    super()
-  }
-
-  render({_n}: CGOptions): string {
-    return `throw ${this.error};` + _n
-  }
-
-  get names(): UsedNames {
-    return this.error.names
-  }
-}
-
-class AnyCode extends Node {
-  constructor(private code: SafeExpr) {
-    super()
-  }
-
-  render({_n}: CGOptions): string {
-    return `${this.code};` + _n
-  }
-
-  optimizeNodes(): this | undefined {
-    return `${this.code}` ? this : undefined
-  }
-
-  optimizeNames(names: UsedNames, constants: Constants): this {
-    this.code = optimizeExpr(this.code, names, constants)
-    return this
-  }
-
-  get names(): UsedNames {
-    return this.code instanceof _CodeOrName ? this.code.names : {}
-  }
-}
-
-abstract class ParentNode extends Node {
-  constructor(readonly nodes: ChildNode[] = []) {
-    super()
-  }
-
-  render(opts: CGOptions): string {
-    return this.nodes.reduce((code, n) => code + n.render(opts), "")
-  }
-
-  optimizeNodes(): this | ChildNode | ChildNode[] | undefined {
-    const {nodes} = this
-    let i = nodes.length
-    while (i--) {
-      const n = nodes[i].optimizeNodes()
-      if (Array.isArray(n)) nodes.splice(i, 1, ...n)
-      else if (n) nodes[i] = n
-      else nodes.splice(i, 1)
-    }
-    return nodes.length > 0 ? this : undefined
-  }
-
-  optimizeNames(names: UsedNames, constants: Constants): this | undefined {
-    const {nodes} = this
-    let i = nodes.length
-    while (i--) {
-      // iterating backwards improves 1-pass optimization
-      const n = nodes[i]
-      if (n.optimizeNames(names, constants)) continue
-      subtractNames(names, n.names)
-      nodes.splice(i, 1)
-    }
-    return nodes.length > 0 ? this : undefined
-  }
-
-  get names(): UsedNames {
-    return this.nodes.reduce((names: UsedNames, n) => addNames(names, n.names), {})
-  }
-
-  // get count(): number {
-  //   return this.nodes.reduce((c, n) => c + n.count, 1)
-  // }
-}
-
-abstract class BlockNode extends ParentNode {
-  render(opts: CGOptions): string {
-    return "{" + opts._n + super.render(opts) + "}" + opts._n
-  }
-}
-
-class Root extends ParentNode {}
-
-class Else extends BlockNode {
-  static readonly kind = "else"
-}
-
-class If extends BlockNode {
-  static readonly kind = "if"
-  else?: If | Else
-  constructor(
-    private condition: Code | boolean,
-    nodes?: ChildNode[]
-  ) {
-    super(nodes)
-  }
-
-  render(opts: CGOptions): string {
-    let code = `if(${this.condition})` + super.render(opts)
-    if (this.else) code += "else " + this.else.render(opts)
-    return code
-  }
-
-  optimizeNodes(): If | ChildNode[] | undefined {
-    super.optimizeNodes()
-    const cond = this.condition
-    if (cond === true) return this.nodes // else is ignored here
-    let e = this.else
-    if (e) {
-      const ns = e.optimizeNodes()
-      e = this.else = Array.isArray(ns) ? new Else(ns) : (ns as Else | undefined)
-    }
-    if (e) {
-      if (cond === false) return e instanceof If ? e : e.nodes
-      if (this.nodes.length) return this
-      return new If(not(cond), e instanceof If ? [e] : e.nodes)
-    }
-    if (cond === false || !this.nodes.length) return undefined
-    return this
-  }
-
-  optimizeNames(names: UsedNames, constants: Constants): this | undefined {
-    this.else = this.else?.optimizeNames(names, constants)
-    if (!(super.optimizeNames(names, constants) || this.else)) return
-    this.condition = optimizeExpr(this.condition, names, constants)
-    return this
-  }
-
-  get names(): UsedNames {
-    const names = super.names
-    addExprNames(names, this.condition)
-    if (this.else) addNames(names, this.else.names)
-    return names
-  }
-
-  // get count(): number {
-  //   return super.count + (this.else?.count || 0)
-  // }
-}
-
-abstract class For extends BlockNode {
-  static readonly kind = "for"
-}
-
-class ForLoop extends For {
-  constructor(private iteration: Code) {
-    super()
-  }
-
-  render(opts: CGOptions): string {
-    return `for(${this.iteration})` + super.render(opts)
-  }
-
-  optimizeNames(names: UsedNames, constants: Constants): this | undefined {
-    if (!super.optimizeNames(names, constants)) return
-    this.iteration = optimizeExpr(this.iteration, names, constants)
-    return this
-  }
-
-  get names(): UsedNames {
-    return addNames(super.names, this.iteration.names)
-  }
-}
-
-class ForRange extends For {
-  constructor(
-    private readonly varKind: Name,
-    private readonly name: Name,
-    private readonly from: SafeExpr,
-    private readonly to: SafeExpr
-  ) {
-    super()
-  }
-
-  render(opts: CGOptions): string {
-    const varKind = opts.es5 ? varKinds.var : this.varKind
-    const {name, from, to} = this
-    return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts)
-  }
-
-  get names(): UsedNames {
-    const names = addExprNames(super.names, this.from)
-    return addExprNames(names, this.to)
-  }
-}
-
-class ForIter extends For {
-  constructor(
-    private readonly loop: "of" | "in",
-    private readonly varKind: Name,
-    private readonly name: Name,
-    private iterable: Code
-  ) {
-    super()
-  }
-
-  render(opts: CGOptions): string {
-    return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts)
-  }
-
-  optimizeNames(names: UsedNames, constants: Constants): this | undefined {
-    if (!super.optimizeNames(names, constants)) return
-    this.iterable = optimizeExpr(this.iterable, names, constants)
-    return this
-  }
-
-  get names(): UsedNames {
-    return addNames(super.names, this.iterable.names)
-  }
-}
-
-class Func extends BlockNode {
-  static readonly kind = "func"
-  constructor(
-    public name: Name,
-    public args: Code,
-    public async?: boolean
-  ) {
-    super()
-  }
-
-  render(opts: CGOptions): string {
-    const _async = this.async ? "async " : ""
-    return `${_async}function ${this.name}(${this.args})` + super.render(opts)
-  }
-}
-
-class Return extends ParentNode {
-  static readonly kind = "return"
-
-  render(opts: CGOptions): string {
-    return "return " + super.render(opts)
-  }
-}
-
-class Try extends BlockNode {
-  catch?: Catch
-  finally?: Finally
-
-  render(opts: CGOptions): string {
-    let code = "try" + super.render(opts)
-    if (this.catch) code += this.catch.render(opts)
-    if (this.finally) code += this.finally.render(opts)
-    return code
-  }
-
-  optimizeNodes(): this {
-    super.optimizeNodes()
-    this.catch?.optimizeNodes() as Catch | undefined
-    this.finally?.optimizeNodes() as Finally | undefined
-    return this
-  }
-
-  optimizeNames(names: UsedNames, constants: Constants): this {
-    super.optimizeNames(names, constants)
-    this.catch?.optimizeNames(names, constants)
-    this.finally?.optimizeNames(names, constants)
-    return this
-  }
-
-  get names(): UsedNames {
-    const names = super.names
-    if (this.catch) addNames(names, this.catch.names)
-    if (this.finally) addNames(names, this.finally.names)
-    return names
-  }
-
-  // get count(): number {
-  //   return super.count + (this.catch?.count || 0) + (this.finally?.count || 0)
-  // }
-}
-
-class Catch extends BlockNode {
-  static readonly kind = "catch"
-  constructor(readonly error: Name) {
-    super()
-  }
-
-  render(opts: CGOptions): string {
-    return `catch(${this.error})` + super.render(opts)
-  }
-}
-
-class Finally extends BlockNode {
-  static readonly kind = "finally"
-  render(opts: CGOptions): string {
-    return "finally" + super.render(opts)
-  }
-}
-
-type StartBlockNode = If | For | Func | Return | Try
-
-type LeafNode = Def | Assign | Label | Break | Throw | AnyCode
-
-type ChildNode = StartBlockNode | LeafNode
-
-type EndBlockNodeType =
-  | typeof If
-  | typeof Else
-  | typeof For
-  | typeof Func
-  | typeof Return
-  | typeof Catch
-  | typeof Finally
-
-type Constants = Record<string, SafeExpr | undefined>
-
-export interface CodeGenOptions {
-  es5?: boolean
-  lines?: boolean
-  ownProperties?: boolean
-}
-
-interface CGOptions extends CodeGenOptions {
-  _n: "\n" | ""
-}
-
-export class CodeGen {
-  readonly _scope: Scope
-  readonly _extScope: ValueScope
-  readonly _values: ScopeValueSets = {}
-  private readonly _nodes: ParentNode[]
-  private readonly _blockStarts: number[] = []
-  private readonly _constants: Constants = {}
-  private readonly opts: CGOptions
-
-  constructor(extScope: ValueScope, opts: CodeGenOptions = {}) {
-    this.opts = {...opts, _n: opts.lines ? "\n" : ""}
-    this._extScope = extScope
-    this._scope = new Scope({parent: extScope})
-    this._nodes = [new Root()]
-  }
-
-  toString(): string {
-    return this._root.render(this.opts)
-  }
-
-  // returns unique name in the internal scope
-  name(prefix: string): Name {
-    return this._scope.name(prefix)
-  }
-
-  // reserves unique name in the external scope
-  scopeName(prefix: string): ValueScopeName {
-    return this._extScope.name(prefix)
-  }
-
-  // reserves unique name in the external scope and assigns value to it
-  scopeValue(prefixOrName: ValueScopeName | string, value: NameValue): Name {
-    const name = this._extScope.value(prefixOrName, value)
-    const vs = this._values[name.prefix] || (this._values[name.prefix] = new Set())
-    vs.add(name)
-    return name
-  }
-
-  getScopeValue(prefix: string, keyOrRef: unknown): ValueScopeName | undefined {
-    return this._extScope.getValue(prefix, keyOrRef)
-  }
-
-  // return code that assigns values in the external scope to the names that are used internally
-  // (same names that were returned by gen.scopeName or gen.scopeValue)
-  scopeRefs(scopeName: Name): Code {
-    return this._extScope.scopeRefs(scopeName, this._values)
-  }
-
-  scopeCode(): Code {
-    return this._extScope.scopeCode(this._values)
-  }
-
-  private _def(
-    varKind: Name,
-    nameOrPrefix: Name | string,
-    rhs?: SafeExpr,
-    constant?: boolean
-  ): Name {
-    const name = this._scope.toName(nameOrPrefix)
-    if (rhs !== undefined && constant) this._constants[name.str] = rhs
-    this._leafNode(new Def(varKind, name, rhs))
-    return name
-  }
-
-  // `const` declaration (`var` in es5 mode)
-  const(nameOrPrefix: Name | string, rhs: SafeExpr, _constant?: boolean): Name {
-    return this._def(varKinds.const, nameOrPrefix, rhs, _constant)
-  }
-
-  // `let` declaration with optional assignment (`var` in es5 mode)
-  let(nameOrPrefix: Name | string, rhs?: SafeExpr, _constant?: boolean): Name {
-    return this._def(varKinds.let, nameOrPrefix, rhs, _constant)
-  }
-
-  // `var` declaration with optional assignment
-  var(nameOrPrefix: Name | string, rhs?: SafeExpr, _constant?: boolean): Name {
-    return this._def(varKinds.var, nameOrPrefix, rhs, _constant)
-  }
-
-  // assignment code
-  assign(lhs: Code, rhs: SafeExpr, sideEffects?: boolean): CodeGen {
-    return this._leafNode(new Assign(lhs, rhs, sideEffects))
-  }
-
-  // `+=` code
-  add(lhs: Code, rhs: SafeExpr): CodeGen {
-    return this._leafNode(new AssignOp(lhs, operators.ADD, rhs))
-  }
-
-  // appends passed SafeExpr to code or executes Block
-  code(c: Block | SafeExpr): CodeGen {
-    if (typeof c == "function") c()
-    else if (c !== nil) this._leafNode(new AnyCode(c))
-    return this
-  }
-
-  // returns code for object literal for the passed argument list of key-value pairs
-  object(...keyValues: [Name | string, SafeExpr | string][]): _Code {
-    const code: CodeItem[] = ["{"]
-    for (const [key, value] of keyValues) {
-      if (code.length > 1) code.push(",")
-      code.push(key)
-      if (key !== value || this.opts.es5) {
-        code.push(":")
-        addCodeArg(code, value)
-      }
-    }
-    code.push("}")
-    return new _Code(code)
-  }
-
-  // `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed)
-  if(condition: Code | boolean, thenBody?: Block, elseBody?: Block): CodeGen {
-    this._blockNode(new If(condition))
-
-    if (thenBody && elseBody) {
-      this.code(thenBody).else().code(elseBody).endIf()
-    } else if (thenBody) {
-      this.code(thenBody).endIf()
-    } else if (elseBody) {
-      throw new Error('CodeGen: "else" body without "then" body')
-    }
-    return this
-  }
-
-  // `else if` clause - invalid without `if` or after `else` clauses
-  elseIf(condition: Code | boolean): CodeGen {
-    return this._elseNode(new If(condition))
-  }
-
-  // `else` clause - only valid after `if` or `else if` clauses
-  else(): CodeGen {
-    return this._elseNode(new Else())
-  }
-
-  // end `if` statement (needed if gen.if was used only with condition)
-  endIf(): CodeGen {
-    return this._endBlockNode(If, Else)
-  }
-
-  private _for(node: For, forBody?: Block): CodeGen {
-    this._blockNode(node)
-    if (forBody) this.code(forBody).endFor()
-    return this
-  }
-
-  // a generic `for` clause (or statement if `forBody` is passed)
-  for(iteration: Code, forBody?: Block): CodeGen {
-    return this._for(new ForLoop(iteration), forBody)
-  }
-
-  // `for` statement for a range of values
-  forRange(
-    nameOrPrefix: Name | string,
-    from: SafeExpr,
-    to: SafeExpr,
-    forBody: (index: Name) => void,
-    varKind: Code = this.opts.es5 ? varKinds.var : varKinds.let
-  ): CodeGen {
-    const name = this._scope.toName(nameOrPrefix)
-    return this._for(new ForRange(varKind, name, from, to), () => forBody(name))
-  }
-
-  // `for-of` statement (in es5 mode replace with a normal for loop)
-  forOf(
-    nameOrPrefix: Name | string,
-    iterable: Code,
-    forBody: (item: Name) => void,
-    varKind: Code = varKinds.const
-  ): CodeGen {
-    const name = this._scope.toName(nameOrPrefix)
-    if (this.opts.es5) {
-      const arr = iterable instanceof Name ? iterable : this.var("_arr", iterable)
-      return this.forRange("_i", 0, _`${arr}.length`, (i) => {
-        this.var(name, _`${arr}[${i}]`)
-        forBody(name)
-      })
-    }
-    return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name))
-  }
-
-  // `for-in` statement.
-  // With option `ownProperties` replaced with a `for-of` loop for object keys
-  forIn(
-    nameOrPrefix: Name | string,
-    obj: Code,
-    forBody: (item: Name) => void,
-    varKind: Code = this.opts.es5 ? varKinds.var : varKinds.const
-  ): CodeGen {
-    if (this.opts.ownProperties) {
-      return this.forOf(nameOrPrefix, _`Object.keys(${obj})`, forBody)
-    }
-    const name = this._scope.toName(nameOrPrefix)
-    return this._for(new ForIter("in", varKind, name, obj), () => forBody(name))
-  }
-
-  // end `for` loop
-  endFor(): CodeGen {
-    return this._endBlockNode(For)
-  }
-
-  // `label` statement
-  label(label: Name): CodeGen {
-    return this._leafNode(new Label(label))
-  }
-
-  // `break` statement
-  break(label?: Code): CodeGen {
-    return this._leafNode(new Break(label))
-  }
-
-  // `return` statement
-  return(value: Block | SafeExpr): CodeGen {
-    const node = new Return()
-    this._blockNode(node)
-    this.code(value)
-    if (node.nodes.length !== 1) throw new Error('CodeGen: "return" should have one node')
-    return this._endBlockNode(Return)
-  }
-
-  // `try` statement
-  try(tryBody: Block, catchCode?: (e: Name) => void, finallyCode?: Block): CodeGen {
-    if (!catchCode && !finallyCode) throw new Error('CodeGen: "try" without "catch" and "finally"')
-    const node = new Try()
-    this._blockNode(node)
-    this.code(tryBody)
-    if (catchCode) {
-      const error = this.name("e")
-      this._currNode = node.catch = new Catch(error)
-      catchCode(error)
-    }
-    if (finallyCode) {
-      this._currNode = node.finally = new Finally()
-      this.code(finallyCode)
-    }
-    return this._endBlockNode(Catch, Finally)
-  }
-
-  // `throw` statement
-  throw(error: Code): CodeGen {
-    return this._leafNode(new Throw(error))
-  }
-
-  // start self-balancing block
-  block(body?: Block, nodeCount?: number): CodeGen {
-    this._blockStarts.push(this._nodes.length)
-    if (body) this.code(body).endBlock(nodeCount)
-    return this
-  }
-
-  // end the current self-balancing block
-  endBlock(nodeCount?: number): CodeGen {
-    const len = this._blockStarts.pop()
-    if (len === undefined) throw new Error("CodeGen: not in self-balancing block")
-    const toClose = this._nodes.length - len
-    if (toClose < 0 || (nodeCount !== undefined && toClose !== nodeCount)) {
-      throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`)
-    }
-    this._nodes.length = len
-    return this
-  }
-
-  // `function` heading (or definition if funcBody is passed)
-  func(name: Name, args: Code = nil, async?: boolean, funcBody?: Block): CodeGen {
-    this._blockNode(new Func(name, args, async))
-    if (funcBody) this.code(funcBody).endFunc()
-    return this
-  }
-
-  // end function definition
-  endFunc(): CodeGen {
-    return this._endBlockNode(Func)
-  }
-
-  optimize(n = 1): void {
-    while (n-- > 0) {
-      this._root.optimizeNodes()
-      this._root.optimizeNames(this._root.names, this._constants)
-    }
-  }
-
-  private _leafNode(node: LeafNode): CodeGen {
-    this._currNode.nodes.push(node)
-    return this
-  }
-
-  private _blockNode(node: StartBlockNode): void {
-    this._currNode.nodes.push(node)
-    this._nodes.push(node)
-  }
-
-  private _endBlockNode(N1: EndBlockNodeType, N2?: EndBlockNodeType): CodeGen {
-    const n = this._currNode
-    if (n instanceof N1 || (N2 && n instanceof N2)) {
-      this._nodes.pop()
-      return this
-    }
-    throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`)
-  }
-
-  private _elseNode(node: If | Else): CodeGen {
-    const n = this._currNode
-    if (!(n instanceof If)) {
-      throw new Error('CodeGen: "else" without "if"')
-    }
-    this._currNode = n.else = node
-    return this
-  }
-
-  private get _root(): Root {
-    return this._nodes[0] as Root
-  }
-
-  private get _currNode(): ParentNode {
-    const ns = this._nodes
-    return ns[ns.length - 1]
-  }
-
-  private set _currNode(node: ParentNode) {
-    const ns = this._nodes
-    ns[ns.length - 1] = node
-  }
-
-  // get nodeCount(): number {
-  //   return this._root.count
-  // }
-}
-
-function addNames(names: UsedNames, from: UsedNames): UsedNames {
-  for (const n in from) names[n] = (names[n] || 0) + (from[n] || 0)
-  return names
-}
-
-function addExprNames(names: UsedNames, from: SafeExpr): UsedNames {
-  return from instanceof _CodeOrName ? addNames(names, from.names) : names
-}
-
-function optimizeExpr<T extends SafeExpr | Code>(expr: T, names: UsedNames, constants: Constants): T
-function optimizeExpr(expr: SafeExpr, names: UsedNames, constants: Constants): SafeExpr {
-  if (expr instanceof Name) return replaceName(expr)
-  if (!canOptimize(expr)) return expr
-  return new _Code(
-    expr._items.reduce((items: CodeItem[], c: SafeExpr | string) => {
-      if (c instanceof Name) c = replaceName(c)
-      if (c instanceof _Code) items.push(...c._items)
-      else items.push(c)
-      return items
-    }, [])
-  )
-
-  function replaceName(n: Name): SafeExpr {
-    const c = constants[n.str]
-    if (c === undefined || names[n.str] !== 1) return n
-    delete names[n.str]
-    return c
-  }
-
-  function canOptimize(e: SafeExpr): e is _Code {
-    return (
-      e instanceof _Code &&
-      e._items.some(
-        (c) => c instanceof Name && names[c.str] === 1 && constants[c.str] !== undefined
-      )
-    )
-  }
-}
-
-function subtractNames(names: UsedNames, from: UsedNames): void {
-  for (const n in from) names[n] = (names[n] || 0) - (from[n] || 0)
-}
-
-export function not<T extends Code | SafeExpr>(x: T): T
-export function not(x: Code | SafeExpr): Code | SafeExpr {
-  return typeof x == "boolean" || typeof x == "number" || x === null ? !x : _`!${par(x)}`
-}
-
-const andCode = mappend(operators.AND)
-
-// boolean AND (&&) expression with the passed arguments
-export function and(...args: Code[]): Code {
-  return args.reduce(andCode)
-}
-
-const orCode = mappend(operators.OR)
-
-// boolean OR (||) expression with the passed arguments
-export function or(...args: Code[]): Code {
-  return args.reduce(orCode)
-}
-
-type MAppend = (x: Code, y: Code) => Code
-
-function mappend(op: Code): MAppend {
-  return (x, y) => (x === nil ? y : y === nil ? x : _`${par(x)} ${op} ${par(y)}`)
-}
-
-function par(x: Code): Code {
-  return x instanceof Name ? x : _`(${x})`
-}