anchor.diff:  
       let (|StartsWith|_|) pattern (str: string) =
           if str.StartsWith pattern then Some pattern else None
  +        
  +    let (|ContainsKey|_|) key (dic: System.Collections.Generic.IDictionary<'k,'v>) =
  +        let success, value = dic.TryGetValue key
  +        if success then Some value else None
   
       let ident name =
           Fabel.IdentValue {name=name; typ=Fabel.UnknownType} |> Fabel.Value
  
positive.code:     let private checkType (args: Fabel.Expr list) successContinuation =
          match args.Head.Type with
          | Fabel.UnknownType ->
              successContinuation () |> Solved
          | Fabel.PrimitiveType kind ->
              match kind with
              | Fabel.Number _ | Fabel.String _ | Fabel.Boolean | Fabel.Unit ->
                  successContinuation () |> Solved
              | Fabel.Function _ | Fabel.Array _ | Fabel.Regex _ ->
                  failwithf "Unexpected operands: %A" args
          | Fabel.DeclaredType typ ->
              Partial (typ.FullName, failwith "TODO: Method name for non-primitive operators", args)
  
      let unaryOp range typ op arg =
          checkType [arg] (fun () ->
              let op = Fabel.UnaryOp op |> Fabel.Value
              Fabel.Apply(op, [arg], false, typ, range))
  
      let binaryOp range typ op left right =
          checkType [left; right] (fun () ->
              let op = Fabel.BinaryOp op |> Fabel.Value
              Fabel.Apply(op, [left; right], false, typ, range))
  
      let logicalOp range typ op left right =
          checkType [left; right] (fun () ->
              let op = Fabel.LogicalOp op |> Fabel.Value
              Fabel.Apply(op, [left; right], false, typ, range))
  
      // TODO: Check primitive args also here?
      let math range typ methName args =
          jsCoreLibCall range typ "Math" methName args |> Solved
  
      let operators com (info: Fabel.ApplyInfo) =
          let range, typ = info.range, info.returnType
          match info.methodName, (info.callee, info.args) with
          // F# Compiler actually converts all logical operations to IfThenElse expressions
          | "&&", TwoArgs (x, y) -> logicalOp range typ LogicalAnd x y
          | "||", TwoArgs (x, y) -> logicalOp range typ LogicalOr x y
          // TODO: If we're comparing against null, we should use non-strict equality
          | "<>", TwoArgs (x, y) -> binaryOp range typ BinaryUnequalStrict x y
          | "=", TwoArgs (x, y) -> binaryOp range typ BinaryEqualStrict x y
          | "+", TwoArgs (x, y) -> binaryOp range typ BinaryPlus x y
          | "-", TwoArgs (x, y) -> binaryOp range typ BinaryMinus x y
          | "*", TwoArgs (x, y) -> binaryOp range typ BinaryMultiply x y
          | "/", TwoArgs (x, y) -> binaryOp range typ BinaryDivide x y
          | "%", TwoArgs (x, y) -> binaryOp range typ BinaryModulus x y
          | "<<<", TwoArgs (x, y) -> binaryOp range typ BinaryShiftLeft x y
          | ">>>", TwoArgs (x, y) -> binaryOp range typ BinaryShiftRightSignPropagating x y
          | "&&&", TwoArgs (x, y) -> binaryOp range typ BinaryAndBitwise x y
          | "|||", TwoArgs (x, y) -> binaryOp range typ BinaryOrBitwise x y
          | "^^^", TwoArgs (x, y) -> binaryOp range typ BinaryXorBitwise x y
          | "~~~", OneArg x -> unaryOp range typ UnaryNotBitwise x
          | "not", OneArg x -> unaryOp range typ UnaryNot x
          | "abs", _ -> math range typ "abs" info.args
          | "acos", _ -> math range typ "acos" info.args
          | "asin", _ -> math range typ "asin" info.args
          | "atan", _ -> math range typ "atan" info.args
          | "atan2", _ -> math range typ "atan2" info.args
          | "ceil", _ -> math range typ "ceil" info.args
          | "cos", _ -> math range typ "cos" info.args
          | "exp", _ -> math range typ "exp" info.args
          | "floor", _ -> math range typ "floor" info.args
          | "log", _ -> math range typ "log" info.args
          | "log10", _ -> math range typ "LN10" info.args
          // TODO: optimize square pow: x * x
          | "pown", _ | "**", _ -> math range typ "pow" info.args
          | "round", _ -> math range typ "round" info.args
          | "sin", _ -> math range typ "sin" info.args
          | "sqrt", _ -> math range typ "sqrt" info.args
          | "tan", _ -> math range typ "tan" info.args
          | _ -> Untouched
  
      let intrinsicFunctions com (info: Fabel.ApplyInfo) =
          match info.methodName, (info.callee, info.args) with
          | "GetArray", TwoArgs (ar, idx) -> Fabel.Get (ar, idx, info.returnType) |> Solved
          | "SetArray", ThreeArgs (ar, idx, value) -> Fabel.Set (ar, Some idx, value, info.range) |> Solved
          | _ -> Untouched
  
      let fsharpMap com (info: Fabel.ApplyInfo) =
          match info.methodName with
          | "add" | "Add" -> Instance "set"
          | "containsKey" | "ContainsKey" -> Instance "has"
          | "Count" -> Getter "size"
          | "isEmpty" | "IsEmpty" ->
              let op = Fabel.UnaryOp UnaryNot |> Fabel.Value
              Fabel.Apply (op, [info.callee.Value], false, info.returnType, info.range)
              |> Inline
          | "Item" -> Instance "get"
          | "Remove" -> Instance "delete"
          | "tryFind"
          | "TryFind" -> Instance "get"
          | "empty" -> failwith "TODO"
          | "exists" -> failwith "TODO"
          | "filter" -> failwith "TODO"
  
negative.code: module Fabel.Plugins.Replacements
  open Fabel
  open Fabel.AST
  
  module private Util =
      let [<Literal>] system = "System."
  